GNUnet 0.22.2
gnunet-service-transport.c File Reference

main for gnunet-service-transport More...

Include dependency graph for gnunet-service-transport.c:

Go to the source code of this file.

Data Structures

struct  MessageUUIDP
 Unique identifier we attach to a message. More...
 
struct  AcknowledgementUUIDP
 Unique identifier to map an acknowledgement to a transmission. More...
 
struct  TransportBackchannelEncapsulationMessage
 Outer layer of an encapsulated backchannel message. More...
 
struct  EphemeralConfirmationPS
 Body by which a peer confirms that it is using an ephemeral key. More...
 
struct  TransportDVBoxPayloadP
 Plaintext of the variable-size payload that is encrypted within a struct TransportBackchannelEncapsulationMessage More...
 
struct  TransportReliabilityBoxMessage
 Outer layer of an encapsulated unfragmented application message sent over an unreliable channel. More...
 
struct  TransportCummulativeAckPayloadP
 Acknowledgement payload. More...
 
struct  TransportReliabilityAckMessage
 Confirmation that the receiver got a GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX. More...
 
struct  TransportFragmentBoxMessage
 Outer layer of an encapsulated fragmented application message. More...
 
struct  DvInitPS
 Content signed by the initiator 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  TransportGlobalNattedAddress
 
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  RingBufferEntry
 Entry for the ring buffer caching messages send to core, when virtual link is available. More...
 
struct  CoreSentContext
 Closure for core_env_sent_cb. More...
 
struct  ReassemblyContext
 Information we keep for a message that we are reassembling. More...
 
struct  VirtualLink
 A virtual link is another reachable peer that is known to CORE. More...
 
struct  PendingAcknowledgement
 Data structure kept when we are waiting for an acknowledgement. More...
 
struct  DistanceVectorHop
 One possible hop towards a DV target. More...
 
struct  DistanceVector
 Entry in our dv_routes table, representing a (set of) distance vector routes to a particular peer. More...
 
struct  QueueEntry
 Entry identifying transmission in one of our struct Queue which still awaits an ACK. More...
 
struct  Queue
 Handle for a queue. More...
 
struct  Neighbour
 A neighbour that at least one communicator is connected to. 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  AddGlobalAddressesContext
 
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...
 
struct  TransportGlobalNattedAddressClosure
 

Macros

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

Typedefs

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

Enumerations

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

Functions

static unsigned int get_age ()
 Get an offset into the transmission history buffer for struct PerformanceData. More...
 
static void free_incoming_request (struct IncomingRequest *ir)
 Release ir data structure. More...
 
static void free_pending_acknowledgement (struct PendingAcknowledgement *pa)
 Release pa data structure. More...
 
static void free_fragment_tree (struct PendingMessage *root)
 Free fragment tree below root, excluding root itself. More...
 
static void free_pending_message (struct PendingMessage *pm)
 Release memory associated with pm and remove pm from associated data structures. More...
 
static void free_reassembly_context (struct ReassemblyContext *rc)
 Free rc. More...
 
static void reassembly_cleanup_task (void *cls)
 Task run to clean up reassembly context of a neighbour that have expired. More...
 
static int free_reassembly_cb (void *cls, uint32_t key, void *value)
 function called to free_reassembly_context(). More...
 
static void free_virtual_link (struct VirtualLink *vl)
 Free virtual link. More...
 
static void free_validation_state (struct ValidationState *vs)
 Free validation state. More...
 
static struct Neighbourlookup_neighbour (const struct GNUNET_PeerIdentity *pid)
 Lookup neighbour for peer pid. More...
 
static struct VirtualLinklookup_virtual_link (const struct GNUNET_PeerIdentity *pid)
 Lookup virtual link for peer pid. More...
 
static void free_distance_vector_hop (struct DistanceVectorHop *dvh)
 Free a dvh. More...
 
static void check_link_down (void *cls)
 Task run to check whether the hops of the cls still are validated, or if we need to core about disconnection. More...
 
static void cores_send_disconnect_info (const struct GNUNET_PeerIdentity *pid)
 Send message to CORE clients that we lost a connection. More...
 
static void free_dv_route (struct DistanceVector *dv)
 Free entry in dv_routes. More...
 
static void notify_monitor (struct TransportClient *tc, const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
 Notify monitor tc about an event. More...
 
static void notify_monitors (const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
 Send information in me about a peer's status with respect to some address to all monitors that care. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 Called whenever a client connects. More...
 
static enum GNUNET_GenericReturnValue remove_global_addresses (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 
static void free_neighbour (struct Neighbour *neighbour, enum GNUNET_GenericReturnValue drop_link)
 Release memory used by neighbour. More...
 
static void core_send_connect_info (struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
 Send message to CORE clients that we lost a connection. More...
 
static void cores_send_connect_info (const struct GNUNET_PeerIdentity *pid)
 Send message to CORE clients that we gained a connection. More...
 
static void transmit_on_queue (void *cls)
 We believe we are ready to transmit a message on a queue. More...
 
static unsigned int check_for_queue_with_higher_prio (struct Queue *queue, struct Queue *queue_head)
 Check if the communicator has another queue with higher prio ready for sending. More...
 
static void schedule_transmit_on_queue (struct GNUNET_TIME_Relative delay, struct Queue *queue, enum GNUNET_SCHEDULER_Priority p)
 Called whenever something changed that might effect when we try to do the next transmission on queue using transmit_on_queue(). More...
 
static void free_queue (struct Queue *queue)
 Free queue. More...
 
static void free_address_list_entry (struct AddressListEntry *ale)
 Free ale. More...
 
static int stop_peer_request (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Stop the peer request in value. More...
 
static void do_shutdown (void *cls)
 Function called when the service shuts down. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
 Called whenever a client is disconnected. More...
 
static int notify_client_connect_info (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Iterator telling new CORE client about all existing connections to peers. More...
 
static void finish_cmc_handling_with_continue (struct CommunicatorMessageContext *cmc, unsigned int free_cmc)
 Send ACK to communicator (if requested) and free cmc. More...
 
static enum GNUNET_GenericReturnValue resume_communicators (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 
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)
 
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 sign_ephemeral (struct DistanceVector *dv)
 Sign ephemeral keys in our dv are current. More...
 
static void free_queue_entry (struct QueueEntry *qe, struct TransportClient *tc)
 
static void free_timedout_queue_entry (void *cls)
 
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_ShortHashCode *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 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 enum GNUNET_GenericReturnValue dv_decrypt (struct DVKeyState *key, void *out, const void *ciph, size_t out_size)
 Perform backchannel encryption using symmetric secret in key to encrypt data from in to dst. More...
 
static void dv_key_clean (struct DVKeyState *key)
 Clean up key material in key. More...
 
static struct GNUNET_TIME_Relative encapsulate_for_dv (struct DistanceVector *dv, unsigned int num_dvhs, struct DistanceVectorHop **dvhs, const struct GNUNET_MessageHeader *hdr, DVMessageHandler use, void *use_cls, enum RouteMessageOptions options, enum GNUNET_GenericReturnValue without_fc)
 Pick a path of dv under constraints options and schedule transmission of hdr. More...
 
static void send_dv_to_neighbour (void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 Wrapper around route_via_neighbour() that matches the DVMessageHandler structure. More...
 
static struct GNUNET_TIME_Relative route_control_message_without_fc (struct VirtualLink *vl, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 We need to transmit hdr to target. More...
 
static void consider_sending_fc (void *cls)
 Something changed on the virtual link with respect to flow control. More...
 
static void task_consider_sending_fc (void *cls)
 Something changed on the virtual link with respect to flow control. More...
 
static char * get_address_without_port (const char *address)
 Get the IP address without the port number. More...
 
static enum GNUNET_GenericReturnValue add_global_addresses (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 
static struct GNUNET_TIME_Relative calculate_rtt (struct DistanceVector *dv)
 
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 shc_cont (void *cls, int success)
 
static struct AddressListEntrycreate_address_entry (struct TransportClient *tc, struct GNUNET_TIME_Relative expiration, enum GNUNET_NetworkType nt, const char *address, uint32_t aid, size_t slen)
 
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)
 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 finish_handling_raw_message (struct VirtualLink *vl, const struct GNUNET_MessageHeader *mh, struct CommunicatorMessageContext *cmc, unsigned int free_cmc)
 
static void handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh)
 Communicator gave us an unencapsulated message to pass as-is to CORE. More...
 
static int check_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
 Communicator gave us a fragment box. More...
 
static void destroy_ack_cummulator (void *cls)
 Clean up an idle cumulative acknowledgement data structure. More...
 
static void transmit_cummulative_ack_cb (void *cls)
 Do the transmission of a cumulative acknowledgement now. More...
 
static void cummulative_ack (const struct GNUNET_PeerIdentity *pid, const struct AcknowledgementUUIDP *ack_uuid, struct GNUNET_TIME_Absolute max_delay)
 Transmit an acknowledgement for ack_uuid to pid delaying transmission by at most ack_delay. More...
 
static int find_by_message_uuid (void *cls, uint32_t key, void *value)
 Iterator called to find a reassembly context by the message UUID in the multihashmap32. More...
 
static void handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
 Communicator gave us a fragment. More...
 
static int check_reliability_box (void *cls, const struct TransportReliabilityBoxMessage *rb)
 Communicator gave us a reliability box. More...
 
static void handle_reliability_box (void *cls, const struct TransportReliabilityBoxMessage *rb)
 Communicator gave us a reliability box. More...
 
static void update_pd_age (struct PerformanceData *pd, unsigned int age)
 Check if we have advanced to another age since the last time. More...
 
static void update_performance_data (struct PerformanceData *pd, struct GNUNET_TIME_Relative rtt, uint16_t bytes_transmitted_ok)
 Update pd based on the latest rtt and the number of bytes that were confirmed to be successfully transmitted. More...
 
static void update_queue_performance (struct Queue *q, struct GNUNET_TIME_Relative rtt, uint16_t bytes_transmitted_ok)
 We have successfully transmitted data via q, update metrics. More...
 
static void update_dvh_performance (struct DistanceVectorHop *dvh, struct GNUNET_TIME_Relative rtt, uint16_t bytes_transmitted_ok)
 We have successfully transmitted data via dvh, update metrics. More...
 
static void completed_pending_message (struct PendingMessage *pm)
 We have completed transmission of pm, remove it from the transmission queues (and if it is a fragment, continue up the tree as necessary). More...
 
static void handle_acknowledged (struct PendingAcknowledgement *pa, struct GNUNET_TIME_Relative ack_delay)
 The pa was acknowledged, process the acknowledgement. More...
 
static int check_reliability_ack (void *cls, const struct TransportReliabilityAckMessage *ra)
 Communicator gave us a reliability ack. More...
 
static void handle_reliability_ack (void *cls, const struct TransportReliabilityAckMessage *ra)
 Communicator gave us a reliability ack. More...
 
static int check_backchannel_encapsulation (void *cls, const struct TransportBackchannelEncapsulationMessage *be)
 Communicator gave us a backchannel encapsulation. More...
 
static void handle_backchannel_encapsulation (void *cls, const struct TransportBackchannelEncapsulationMessage *be)
 Communicator gave us a backchannel encapsulation. More...
 
static void path_cleanup_cb (void *cls)
 Task called when we should check if any of the DV paths we have learned to a target are due for garbage collection. More...
 
static void send_msg_from_cache (struct VirtualLink *vl)
 
static void activate_core_visible_dv_path (struct DistanceVectorHop *hop)
 The hop is a validated path to the respective target peer and we should tell core about it – and schedule a job to revoke the state. More...
 
static int learn_dv_path (const struct GNUNET_PeerIdentity *path, unsigned int path_len, struct GNUNET_TIME_Relative network_latency, struct GNUNET_TIME_Absolute path_valid_until)
 We have learned a path through the network to some other peer, add it to our DV data structure (returning GNUNET_YES on success). More...
 
static int check_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
 Communicator gave us a DV learn message. More...
 
static void forward_dv_learn (const struct GNUNET_PeerIdentity *next_hop, const struct TransportDVLearnMessage *msg, uint16_t bi_history, uint16_t nhops, const struct DVPathEntryP *hops, struct GNUNET_TIME_Absolute in_time)
 Build and forward a DV learn message to next_hop. More...
 
static int validate_dv_initiator_signature (struct GNUNET_TIME_AbsoluteNBO sender_monotonic_time, const struct GNUNET_PeerIdentity *init, const struct GNUNET_CRYPTO_ChallengeNonceP *challenge, const struct GNUNET_CRYPTO_EddsaSignature *init_sig)
 Check signature of type GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR. More...
 
static int dv_neighbour_selection (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Function called for each neighbour during handle_dv_learn. More...
 
static int dv_neighbour_transmission (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Function called for each neighbour during handle_dv_learn. More...
 
static unsigned int calculate_fork_degree (unsigned int hops_taken, unsigned int neighbour_count, unsigned int eligible_count)
 Computes the number of neighbours we should forward a DVInit message to given that it has so far taken hops_taken hops though the network and that the number of neighbours we have in total is neighbour_count, out of which eligible_count are not yet on the path. More...
 
static void neighbour_store_dvmono_cb (void *cls, int success)
 Function called when peerstore is done storing a DV monotonic time. More...
 
static struct GNUNET_TIME_Relative get_network_latency (const struct TransportDVLearnMessage *dvl)
 
static void handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
 Communicator gave us a DV learn message. More...
 
static int check_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
 Communicator gave us a DV box. More...
 
static void forward_dv_box (struct Neighbour *next_hop, struct TransportDVBoxMessage *hdr, uint16_t total_hops, uint16_t num_hops, const struct GNUNET_PeerIdentity *hops, const void *enc_payload, uint16_t enc_payload_size)
 Create a DV Box message and queue it for transmission to 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 struct Queuefind_queue (const struct GNUNET_PeerIdentity *pid, const char *address)
 Find the queue matching pid and address. 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 hello_for_incoming_cb (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
 
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 hello_for_incoming_error_cb (void *cls)
 
static void hello_for_incoming_sync_cb (void *cls)
 
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 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 void revalidation_start_cb (void *cls)
 
static enum GNUNET_GenericReturnValue revalidate_map_it (void *cls, const struct GNUNET_HashCode *key, void *value)
 
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 message. More...
 
static int check_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
 Communicator gave us a transport address validation response. More...
 
static void iterate_address_start_burst (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
 
static void check_for_burst_address (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 
static void burst_timeout (void *cls)
 
static void start_burst (void *cls)
 
static void queue_burst (void *cls)
 
static void handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
 Communicator gave us a transport address validation response. More...
 
static int check_add_queue_message (void *cls, const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
 New queue became available. More...
 
static void set_pending_message_uuid (struct PendingMessage *pm)
 If necessary, generates the UUID for a pm. More...
 
static struct PendingAcknowledgementprepare_pending_acknowledgement (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
 Setup data structure waiting for acknowledgements. More...
 
static struct PendingMessagefragment_message (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
 Fragment the given pm to the given mtu. More...
 
static struct PendingMessagereliability_box_message (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
 Reliability-box the given pm. More...
 
static void reorder_root_pm (struct PendingMessage *pm, struct GNUNET_TIME_Absolute next_attempt)
 
static unsigned int check_next_attempt_tree (struct PendingMessage *pm, struct PendingMessage *root)
 
static void harmonize_flight_round (struct PendingMessage *pm)
 
static void update_pm_next_attempt (struct PendingMessage *pm, struct GNUNET_TIME_Absolute next_attempt)
 Change the value of the next_attempt field of pm to next_attempt and re-order pm in the transmission list as required by the new timestamp. More...
 
static void select_best_pending_from_link (struct PendingMessageScoreContext *sc, struct Queue *queue, struct VirtualLink *vl, struct DistanceVectorHop *dvh, size_t overhead)
 Select the best pending message from vl for transmission via queue. More...
 
static void extract_box_cb (void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
 Function to call to further operate on the now DV encapsulated message hdr, forwarding it via next_hop under respect of options. More...
 
static void handle_del_queue_message (void *cls, const struct GNUNET_TRANSPORT_DelQueueMessage *dqm)
 Queue to a peer went down. More...
 
static void handle_send_message_ack (void *cls, const struct GNUNET_TRANSPORT_SendMessageToAck *sma)
 Message was transmitted. More...
 
static void handle_burst_finished ()
 The burst finished. 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 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 iterate_address_and_compare_cb (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
 
static enum GNUNET_GenericReturnValue contains_address (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 
static void check_for_global_natted_error_cb (void *cls)
 
static void check_for_global_natted_sync_cb (void *cls)
 
static void check_for_global_natted (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
 
static void handle_add_queue_message (void *cls, const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
 New queue became available. More...
 
static void handle_update_queue_message (void *cls, const struct GNUNET_TRANSPORT_UpdateQueueMessage *msg)
 Handle updates to queues. More...
 
static void handle_queue_create_ok (void *cls, const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
 Communicator tells us that our request to create a queue "worked", that is setting up the queue is now in process. More...
 
static void handle_queue_create_fail (void *cls, const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
 Communicator tells us that our request to create a queue failed. More...
 
static void handle_suggest_cancel (void *cls, const struct ExpressPreferenceMessage *msg)
 We have received a struct ExpressPreferenceMessage from an application client. More...
 
static void hello_for_client_cb (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
 
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 hello_for_client_error_cb (void *cls)
 
static void hello_for_client_sync_cb (void *cls)
 
static void handle_suggest (void *cls, const struct ExpressPreferenceMessage *msg)
 We have received a struct ExpressPreferenceMessage from an application client. More...
 
static int check_request_hello_validation (void *cls, const struct RequestHelloValidationMessage *m)
 Check GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION messages. More...
 
static void handle_request_hello_validation (void *cls, const struct RequestHelloValidationMessage *m)
 A client encountered an address of another peer. More...
 
static int free_neighbour_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free neighbour entry. More...
 
static int free_dv_routes_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free DV route entry. More...
 
static int free_validation_state_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free validation state. More...
 
static int free_pending_ack_cb (void *cls, const struct GNUNET_Uuid *key, void *value)
 Free pending acknowledgement. More...
 
static int free_ack_cummulator_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
 Free acknowledgement cummulator. More...
 
static void shutdown_task (void *cls)
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Initiate transport service. More...
 
 GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "transport", GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(suggest, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST, struct ExpressPreferenceMessage, NULL), GNUNET_MQ_hd_fixed_size(suggest_cancel, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL, struct ExpressPreferenceMessage, NULL), GNUNET_MQ_hd_var_size(request_hello_validation, GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION, struct RequestHelloValidationMessage, NULL), GNUNET_MQ_hd_fixed_size(client_start, GNUNET_MESSAGE_TYPE_TRANSPORT_START, struct StartMessage, NULL), GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, struct OutboundMessage, NULL), GNUNET_MQ_hd_fixed_size(client_recv_ok, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK, struct RecvOkMessage, NULL), GNUNET_MQ_hd_var_size(communicator_available, GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR, struct GNUNET_TRANSPORT_CommunicatorAvailableMessage, NULL), GNUNET_MQ_hd_var_size(communicator_backchannel, GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL, struct GNUNET_TRANSPORT_CommunicatorBackchannel, NULL), GNUNET_MQ_hd_var_size(add_address, GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS, struct GNUNET_TRANSPORT_AddAddressMessage, NULL), GNUNET_MQ_hd_fixed_size(del_address, GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS, struct GNUNET_TRANSPORT_DelAddressMessage, NULL), GNUNET_MQ_hd_var_size(incoming_msg, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG, struct GNUNET_TRANSPORT_IncomingMessage, NULL), GNUNET_MQ_hd_fixed_size(queue_create_ok, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK, struct GNUNET_TRANSPORT_CreateQueueResponse, NULL), GNUNET_MQ_hd_fixed_size(queue_create_fail, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL, struct GNUNET_TRANSPORT_CreateQueueResponse, NULL), GNUNET_MQ_hd_var_size(add_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP, struct GNUNET_TRANSPORT_AddQueueMessage, NULL), GNUNET_MQ_hd_fixed_size(update_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE, struct GNUNET_TRANSPORT_UpdateQueueMessage, NULL), GNUNET_MQ_hd_fixed_size(del_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN, struct GNUNET_TRANSPORT_DelQueueMessage, NULL), GNUNET_MQ_hd_fixed_size(send_message_ack, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK, struct GNUNET_TRANSPORT_SendMessageToAck, NULL), GNUNET_MQ_hd_fixed_size(burst_finished, GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_FINISHED, struct GNUNET_TRANSPORT_BurstFinished, 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 RingBufferEntryring_buffer [RING_BUFFER_SIZE]
 Ring buffer for a CORE message we did not deliver to CORE, because of missing virtual link to sender. More...
 
static unsigned int ring_buffer_head
 Head of the ring buffer. More...
 
static unsigned int is_ring_buffer_full
 Is the ring buffer filled up to RING_BUFFER_SIZE. More...
 
static struct PendingMessagering_buffer_dv [RING_BUFFER_SIZE]
 Ring buffer for a forwarded DVBox message we did not deliver to the next hop, because of missing virtual link that hop. More...
 
static unsigned int ring_buffer_dv_head
 Head of the ring buffer. More...
 
static unsigned int is_ring_buffer_dv_full
 Is the ring buffer filled up to RING_BUFFER_SIZE. More...
 
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...
 
struct GNUNET_HELLO_BuilderGST_my_hello
 Our HELLO. 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_MultiHashMaprevalidation_map
 Map from addresses to struct ValidationState entries describing addresses we are aware of and their validity state. More...
 
static struct GNUNET_CONTAINER_MultiPeerMaplinks
 Map from PIDs to struct VirtualLink entries describing links CORE knows to exist. More...
 
static struct GNUNET_CONTAINER_MultiShortmapdvlearn_map
 Map from challenges to struct LearnLaunchEntry values. More...
 
static struct LearnLaunchEntrylle_head = NULL
 Head of a DLL sorted by launch time. More...
 
static struct LearnLaunchEntrylle_tail = NULL
 Tail of a DLL sorted by launch time. More...
 
static struct GNUNET_CONTAINER_Heapvalidation_heap
 MIN Heap sorted by "next_challenge" to struct ValidationState entries sorting addresses we are aware of by when we should next try to (re)validate (or expire) them. More...
 
struct GNUNET_NAT_Handlenh
 Handle for connect to the NAT service. 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 IncomingRequestir_head
 List of incoming connections where we are trying to get a connection back established. More...
 
static struct IncomingRequestir_tail
 Tail of DLL starting at ir_head. More...
 
static unsigned int ir_total
 Length of the DLL starting at ir_head. More...
 
static unsigned long long logging_uuid_gen
 Generator of logging_uuid in struct PendingMessage. More...
 
static enum GNUNET_GenericReturnValue burst_running
 Is there a burst running? More...
 
static struct GNUNET_TIME_Absolute hello_mono_time
 Monotonic time we use for HELLOs generated at this time. More...
 
static int in_shutdown
 Indication if we have received a shutdown signal and are in the process of cleaning up. More...
 
static struct GNUNET_SCHEDULER_Taskburst_task
 The task to start the burst. More...
 
struct GNUNET_SCHEDULER_Taskburst_timeout_task
 
enum GNUNET_GenericReturnValue use_burst
 

Detailed Description

main for gnunet-service-transport

Author
Christian Grothoff

TODO: Implement next:

  • review retransmission logic, right now there is no smartness there! => congestion control, etc [PERFORMANCE-BASICS]

Optimizations-Statistics:

  • Track ACK losses based on ACK-counter [ROUTING]
  • Need to track total bandwidth per VirtualLink and adjust how frequently we send FC messages based on bandwidth-delay-product (and relation to the window size!). See OPTIMIZE-FC-BDP.
  • Consider more statistics in check_connection_quality() [FIXME-CONQ-STATISTICS]
  • Adapt available_fc_window_size, using larger values for high-bandwidth and high-latency links if we have the RAM [GOODPUT / utilization / stalls]
  • Set last_window_consum_limit promise properly based on latency and bandwidth of the respective connection [GOODPUT / utilization / stalls]

Optimizations-DV:

  • When forwarding DV learn messages, if a peer is reached that has a bidirectional link to the origin beyond 1st hop, do NOT forward it to peers other than the origin, as there is clearly a better path directly from the origin to whatever else we could reach.
  • When we passively learned DV (with unconfirmed freshness), we right now add the path to our list but with a zero path_valid_until time and only use it for unconfirmed routes. However, we could consider triggering an explicit validation mechanism ourselves, specifically routing a challenge-response message over the path [ROUTING] = if available, try to confirm unconfirmed DV paths when trying to establish virtual link for a struct IncomingRequest. (i.e. if DVH is unconfirmed, incoming requests cause us to try to validate a passively learned path (requires new message type!))

Optimizations-Fragmentation:

  • Fragments send over a reliable channel could do without the AcknowledgementUUIDP altogether, as they won't be acked! [BANDWIDTH] (-> have 2nd type of acknowledgment message; low priority, as we do not have an MTU-limited reliable communicator) [FIXME-FRAG-REL-UUID]
  • if messages are below MTU, consider adding ACKs and other stuff to the same transmission to avoid tiny messages (requires planning at receiver, and additional MST-style demultiplex at receiver!) [PACKET COUNT]

Optimizations-internals:

  • queue_send_msg by API design has to make a copy of the payload, and route_message on top of that requires a malloc/free. Change design to approximate "zero" copy better... [CPU]
  • could avoid copying body of message into each fragment and keep fragments as just pointers into the original message and only fully build fragments just before transmission (optimization, should reduce CPU and memory use) [CPU, MEMORY]

Definition in file gnunet-service-transport.c.

Macro Definition Documentation

◆ RING_BUFFER_SIZE

#define RING_BUFFER_SIZE   16

Size of ring buffer to cache CORE and forwarded DVBox messages.

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

◆ MAX_FC_RETRANSMIT_COUNT

#define MAX_FC_RETRANSMIT_COUNT   1000

Maximum number of FC retransmissions for a running retransmission task.

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

◆ MAX_CUMMULATIVE_ACKS

#define MAX_CUMMULATIVE_ACKS   64

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

Larger values may save a bit of bandwidth.

Definition at line 99 of file gnunet-service-transport.c.

◆ FC_NO_CHANGE_REPLY_PROBABILITY

#define FC_NO_CHANGE_REPLY_PROBABILITY   8

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

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

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

◆ IN_PACKET_SIZE_WITHOUT_MTU

#define IN_PACKET_SIZE_WITHOUT_MTU   128

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

Definition at line 119 of file gnunet-service-transport.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 125 of file gnunet-service-transport.c.

◆ DEFAULT_WINDOW_SIZE

#define DEFAULT_WINDOW_SIZE   (128 * 1024)

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

Definition at line 131 of file gnunet-service-transport.c.

◆ MAX_INCOMING_REQUEST

#define MAX_INCOMING_REQUEST   16

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

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

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

◆ MAX_DV_DISCOVERY_SELECTION

#define MAX_DV_DISCOVERY_SELECTION   16

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

Definition at line 147 of file gnunet-service-transport.c.

◆ RECV_WINDOW_SIZE

#define RECV_WINDOW_SIZE   4

Window size.

How many messages to the same target do we pass to CORE without a RECV_OK in between? Small values limit throughput, 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 157 of file gnunet-service-transport.c.

◆ MIN_DV_PATH_LENGTH_FOR_INITIATOR

#define MIN_DV_PATH_LENGTH_FOR_INITIATOR   3

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

FIXME: allow initiator some control here instead?

Definition at line 166 of file gnunet-service-transport.c.

◆ MAX_DV_HOPS_ALLOWED

#define MAX_DV_HOPS_ALLOWED   16

Maximum DV distance allowed ever.

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

◆ MAX_DV_LEARN_PENDING

#define MAX_DV_LEARN_PENDING   64

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

Definition at line 177 of file gnunet-service-transport.c.

◆ MAX_DV_PATHS_TO_TARGET

#define MAX_DV_PATHS_TO_TARGET   3

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

Definition at line 182 of file gnunet-service-transport.c.

◆ DELAY_WARN_THRESHOLD

#define DELAY_WARN_THRESHOLD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

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

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

Definition at line 189 of file gnunet-service-transport.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 196 of file gnunet-service-transport.c.

◆ DEFAULT_ACK_WAIT_DURATION

#define DEFAULT_ACK_WAIT_DURATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

Default value for how long we wait for reliability ack.

Definition at line 202 of file gnunet-service-transport.c.

◆ DV_QUALITY_RTT_THRESHOLD

#define DV_QUALITY_RTT_THRESHOLD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

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

Definition at line 210 of file gnunet-service-transport.c.

◆ DV_PATH_VALIDITY_TIMEOUT

#define DV_PATH_VALIDITY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

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

Definition at line 217 of file gnunet-service-transport.c.

◆ BACKCHANNEL_INACTIVITY_TIMEOUT

#define BACKCHANNEL_INACTIVITY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

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

Definition at line 224 of file gnunet-service-transport.c.

◆ DV_PATH_DISCOVERY_FREQUENCY

#define DV_PATH_DISCOVERY_FREQUENCY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)

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

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

◆ EPHEMERAL_VALIDITY

#define EPHEMERAL_VALIDITY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

How long are ephemeral keys valid?

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

◆ REASSEMBLY_EXPIRATION

#define REASSEMBLY_EXPIRATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)

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

Definition at line 243 of file gnunet-service-transport.c.

◆ FAST_VALIDATION_CHALLENGE_FREQ

#define FAST_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)

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

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

◆ MAX_VALIDATION_CHALLENGE_FREQ

#define MAX_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1)

What is the slowest rate at which we send challenges?

Definition at line 256 of file gnunet-service-transport.c.

◆ ACK_CUMMULATOR_TIMEOUT

#define ACK_CUMMULATOR_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

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

Definition at line 264 of file gnunet-service-transport.c.

◆ DV_LEARN_BASE_FREQUENCY

#define DV_LEARN_BASE_FREQUENCY   GNUNET_TIME_UNIT_MINUTES

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

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

◆ DV_LEARN_QUALITY_THRESHOLD

#define DV_LEARN_QUALITY_THRESHOLD   100

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

Definition at line 277 of file gnunet-service-transport.c.

◆ MAX_ADDRESS_VALID_UNTIL

#define MAX_ADDRESS_VALID_UNTIL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1)

When do we forget an invalid address for sure?

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

◆ ADDRESS_VALIDATION_LIFETIME

#define ADDRESS_VALIDATION_LIFETIME    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)

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

Definition at line 288 of file gnunet-service-transport.c.

◆ MIN_DELAY_ADDRESS_VALIDATION

#define MIN_DELAY_ADDRESS_VALIDATION   GNUNET_TIME_UNIT_MILLISECONDS

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

Definition at line 297 of file gnunet-service-transport.c.

◆ VALIDATION_RTT_BUFFER_FACTOR

#define VALIDATION_RTT_BUFFER_FACTOR   3

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

Definition at line 305 of file gnunet-service-transport.c.

◆ COMMUNICATOR_TOTAL_QUEUE_LIMIT

#define COMMUNICATOR_TOTAL_QUEUE_LIMIT   512

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

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

Definition at line 313 of file gnunet-service-transport.c.

◆ QUEUE_LENGTH_LIMIT

#define QUEUE_LENGTH_LIMIT   32

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

Definition at line 320 of file gnunet-service-transport.c.

◆ QUEUE_ENTRY_TIMEOUT

#define QUEUE_ENTRY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

Definition at line 325 of file gnunet-service-transport.c.

◆ RTT_DIFF

Difference of the average RTT for the DistanceVector calculate by us and the target we are willing to accept for starting the burst.

Definition at line 332 of file gnunet-service-transport.c.

Typedef Documentation

◆ DVMessageHandler

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

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

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

Definition at line 5131 of file gnunet-service-transport.c.

Enumeration Type Documentation

◆ ClientType

enum ClientType

What type of client is the struct TransportClient about?

Enumerator
CT_NONE 

We do not know yet (client is fresh).

CT_CORE 

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

CT_MONITOR 

It is a monitor, forward monitor data.

CT_COMMUNICATOR 

It is a communicator, use for communication.

CT_APPLICATION 

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

TOPOLOGY, DHT or CADET).

Definition at line 1022 of file gnunet-service-transport.c.

1023{
1027 CT_NONE = 0,
1028
1032 CT_CORE = 1,
1033
1037 CT_MONITOR = 2,
1038
1042 CT_COMMUNICATOR = 3,
1043
1047 CT_APPLICATION = 4
1048};
@ CT_APPLICATION
"Application" telling us where to connect (i.e.
@ CT_MONITOR
It is a monitor, forward monitor data.
@ CT_NONE
We do not know yet (client is fresh).
@ CT_CORE
Is the CORE service, we need to forward traffic to it.
@ CT_COMMUNICATOR
It is a communicator, use for communication.

◆ RouteMessageOptions

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

Enumerator
RMO_NONE 

Only confirmed, non-DV direct neighbours.

RMO_DV_ALLOWED 

We are allowed to use DV routing for this hdr.

RMO_UNCONFIRMED_ALLOWED 

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

RMO_ANYTHING_GOES 

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

RMO_REDUNDANT 

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

(We do at most 2 transmissions.)

Definition at line 1055 of file gnunet-service-transport.c.

1056{
1060 RMO_NONE = 0,
1061
1065 RMO_DV_ALLOWED = 1,
1066
1071
1076
1082 RMO_REDUNDANT = 4
1083};
@ RMO_UNCONFIRMED_ALLOWED
We are allowed to use unconfirmed queues or DV routes for this message.
@ RMO_DV_ALLOWED
We are allowed to use DV routing for this hdr.
@ RMO_REDUNDANT
If we have multiple choices, it is OK to send this message over multiple channels at the same time to...
@ RMO_NONE
Only confirmed, non-DV direct neighbours.
@ RMO_ANYTHING_GOES
Reliable and unreliable, DV and non-DV are all acceptable.

◆ PendingMessageType

Types of different pending messages.

Enumerator
PMT_CORE 

Ordinary message received from the CORE service.

PMT_FRAGMENT_BOX 

Fragment box.

PMT_RELIABILITY_BOX 

Reliability box.

PMT_DV_BOX 

Pending message created during forward_dv_box().

Definition at line 2205 of file gnunet-service-transport.c.

2206{
2210 PMT_CORE = 0,
2211
2215 PMT_FRAGMENT_BOX = 1,
2216
2221
2225 PMT_DV_BOX = 3
2226};
@ PMT_FRAGMENT_BOX
Fragment box.
@ PMT_DV_BOX
Pending message created during forward_dv_box().
@ PMT_CORE
Ordinary message received from the CORE service.
@ PMT_RELIABILITY_BOX
Reliability box.

Function Documentation

◆ get_age()

static unsigned int get_age ( )
static

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

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

An 'age' lasts 15 minute slots.

Returns
current age of the world

Definition at line 3081 of file gnunet-service-transport.c.

3082{
3083 struct GNUNET_TIME_Absolute now;
3084
3085 now = GNUNET_TIME_absolute_get ();
3086 return now.abs_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us / 15;
3087}
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
#define GNUNET_TIME_UNIT_MINUTES
One minute.
Time for absolute times used by GNUnet, in microseconds.

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

Referenced by update_performance_data().

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

◆ free_incoming_request()

static void free_incoming_request ( struct IncomingRequest ir)
static

Release ir data structure.

Parameters
irdata structure to release

Definition at line 3096 of file gnunet-service-transport.c.

3097{
3099 GNUNET_assert (ir_total > 0);
3100 ir_total--;
3101 if (NULL != ir->nc)
3103 ir->nc = NULL;
3104 GNUNET_free (ir);
3105}
static struct IncomingRequest * ir_tail
Tail of DLL starting at ir_head.
static unsigned int ir_total
Length of the DLL starting at ir_head.
static struct IncomingRequest * ir_head
List of incoming connections where we are trying to get a connection back established.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_PEERSTORE_monitor_stop(struct GNUNET_PEERSTORE_Monitor *zm)
Stop monitoring.
struct GNUNET_PEERSTORE_Monitor * nc
Notify context for new HELLOs.

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_PEERSTORE_monitor_stop(), ir_head, ir_tail, ir_total, and IncomingRequest::nc.

Referenced by do_shutdown(), and handle_validation_challenge().

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

◆ free_pending_acknowledgement()

static void free_pending_acknowledgement ( struct PendingAcknowledgement pa)
static

Release pa data structure.

Parameters
padata structure to release

Definition at line 3114 of file gnunet-service-transport.c.

3115{
3116 struct Queue *q = pa->queue;
3117 struct PendingMessage *pm = pa->pm;
3118 struct DistanceVectorHop *dvh = pa->dvh;
3119
3121 "free_pending_acknowledgement\n");
3122 if (NULL != q)
3123 {
3124 GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa);
3125 pa->queue = NULL;
3126 }
3127 if (NULL != pm)
3128 {
3130 "remove pa from message\n");
3132 "remove pa from message %" PRIu64 "\n",
3133 pm->logging_uuid);
3135 "remove pa from message %u\n",
3136 pm->pmt);
3138 "remove pa from message %s\n",
3140 GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
3141 pa->pm = NULL;
3142 }
3143 if (NULL != dvh)
3144 {
3145 GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
3146 pa->queue = NULL;
3147 }
3150 &pa->ack_uuid.value,
3151 pa));
3152 GNUNET_free (pa);
3153}
static struct GNUNET_REVOCATION_Query * q
Handle for revocation query.
static struct GNUNET_CONTAINER_MultiUuidmap * pending_acks
Map of pending acknowledgements, mapping struct AcknowledgementUUID to a struct PendingAcknowledgemen...
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
#define GNUNET_CONTAINER_MDLL_remove(mdll, head, tail, element)
Remove an element from a MDLL.
enum GNUNET_GenericReturnValue 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.
#define GNUNET_log(kind,...)
@ GNUNET_YES
const char * GNUNET_uuid2s(const struct GNUNET_Uuid *uuid)
Convert a UUID to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_Uuid value
The UUID value.
One possible hop towards a DV target.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs that used our path.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs that used our path.
struct AcknowledgementUUIDP ack_uuid
Unique identifier for this transmission operation.
struct PendingMessage * pm
Message that was transmitted, may be NULL if the message was ACKed via another channel.
struct Queue * queue
Queue used for transmission, NULL if the queue has been destroyed (which may happen before we get an ...
struct DistanceVectorHop * dvh
Distance vector path chosen for this transmission, NULL if transmission was to a direct neighbour OR ...
List containing all messages that are yet to be send.
Handle for a queue.

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

Referenced by free_pending_ack_cb(), and handle_acknowledged().

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

◆ free_fragment_tree()

static void free_fragment_tree ( struct PendingMessage root)
static

Free fragment tree below root, excluding root itself.

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

Parameters
rootroot of the tree to free

Definition at line 3165 of file gnunet-service-transport.c.

3166{
3167 struct PendingMessage *frag;
3168
3169 while (NULL != (frag = root->head_frag))
3170 {
3171 struct PendingAcknowledgement *pa;
3172
3173 free_fragment_tree (frag);
3174 while (NULL != (pa = frag->pa_head))
3175 {
3176 GNUNET_CONTAINER_MDLL_remove (pm, frag->pa_head, frag->pa_tail, pa);
3177 pa->pm = NULL;
3178 }
3179 GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag, frag);
3180 if (NULL != frag->qe)
3181 {
3182 GNUNET_assert (frag == frag->qe->pm);
3183 frag->qe->pm = NULL;
3184 }
3186 "Free frag %p\n",
3187 frag);
3188 GNUNET_free (frag);
3189 }
3190}
static void free_fragment_tree(struct PendingMessage *root)
Free fragment tree below root, excluding root itself.
Data structure kept when we are waiting for an acknowledgement.
struct PendingMessage * tail_frag
Tail of a MDLL of fragments created for this core message.
struct QueueEntry * qe
Set to non-NULL value if this message is currently being given to a communicator and we are awaiting ...
struct PendingMessage * head_frag
Head of a MDLL of fragments created for this core message.
struct PendingAcknowledgement * pa_tail
Tail of DLL of PAs for this pending message.
struct PendingAcknowledgement * pa_head
Head of DLL of PAs for this pending message.
struct PendingMessage * pm
Pending message this entry is for, or NULL for none.

References free_fragment_tree(), GNUNET_assert, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, PendingMessage::head_frag, PendingMessage::pa_head, PendingMessage::pa_tail, PendingAcknowledgement::pm, QueueEntry::pm, pm, PendingMessage::qe, and PendingMessage::tail_frag.

Referenced by free_fragment_tree(), and free_pending_message().

Here is the call graph for this function:
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 3201 of file gnunet-service-transport.c.

3202{
3203 struct TransportClient *tc = pm->client;
3204 struct VirtualLink *vl = pm->vl;
3205 struct PendingAcknowledgement *pa;
3206
3208 "Freeing pm %p\n",
3209 pm);
3210 if (NULL != tc)
3211 {
3213 tc->details.core.pending_msg_head,
3214 tc->details.core.pending_msg_tail,
3215 pm);
3216 }
3217 if ((NULL != vl) && (NULL == pm->frag_parent))
3218 {
3220 "Removing pm %" PRIu64 "\n",
3221 pm->logging_uuid);
3223 vl->pending_msg_head,
3224 vl->pending_msg_tail,
3225 pm);
3226 }
3227 else if (NULL != pm->frag_parent && PMT_DV_BOX != pm->pmt)
3228 {
3229 struct PendingMessage *root = pm->frag_parent;
3230
3231 while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
3232 root = root->frag_parent;
3233
3234 root->frag_count--;
3235 }
3236 while (NULL != (pa = pm->pa_head))
3237 {
3238 if (NULL == pa)
3240 "free pending pa null\n");
3241 if (NULL == pm->pa_tail)
3243 "free pending pa_tail null\n");
3244 if (NULL == pa->prev_pa)
3246 "free pending pa prev null\n");
3247 if (NULL == pa->next_pa)
3249 "free pending pa next null\n");
3250 GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
3251 pa->pm = NULL;
3252 }
3253
3255 if (NULL != pm->qe)
3256 {
3257 GNUNET_assert (pm == pm->qe->pm);
3258 pm->qe->pm = NULL;
3259 }
3260 if (NULL != pm->bpm)
3261 {
3262 free_fragment_tree (pm->bpm);
3263 if (NULL != pm->bpm->qe)
3264 {
3265 struct QueueEntry *qe = pm->bpm->qe;
3266
3267 qe->pm = NULL;
3268 }
3269 GNUNET_free (pm->bpm);
3270 }
3271
3272 GNUNET_free (pm);
3274 "Freeing pm done\n");
3275}
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:431
struct PendingAcknowledgement * next_pa
Pointers for the DLL of all pending acknowledgements.
struct PendingAcknowledgement * prev_pa
Pointers for the DLL of all pending acknowledgements.
struct PendingMessage * frag_parent
Our parent in the fragmentation tree.
enum PendingMessageType pmt
Type of the pending message.
uint16_t frag_count
How many fragments do we have?
Entry identifying transmission in one of our struct Queue which still awaits an ACK.
Client connected to the transport service.

References PendingMessage::frag_count, PendingMessage::frag_parent, free_fragment_tree(), GNUNET_assert, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, PendingAcknowledgement::next_pa, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, PendingAcknowledgement::pm, pm, PendingMessage::pmt, PMT_DV_BOX, PendingAcknowledgement::prev_pa, qe, and tc.

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

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

◆ free_reassembly_context()

static void free_reassembly_context ( struct ReassemblyContext rc)
static

Free rc.

Parameters
rcdata structure to free

Definition at line 3284 of file gnunet-service-transport.c.

3285{
3286 struct VirtualLink *vl = rc->virtual_link;
3287
3291 rc->msg_uuid.uuid,
3292 rc));
3293 GNUNET_free (rc);
3294}
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
void * GNUNET_CONTAINER_heap_remove_node(struct GNUNET_CONTAINER_HeapNode *node)
Removes a node from the heap.
@ GNUNET_OK
uint64_t uuid
Unique value, generated by incrementing the message_uuid_ctr of struct Neighbour.
struct GNUNET_CONTAINER_HeapNode * hn
Entry in the reassembly heap (sorted by expiration).
struct MessageUUIDP msg_uuid
Original message ID for of the message that all the fragments belong to.
struct VirtualLink * virtual_link
Which neighbour is this context for?

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

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

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

◆ reassembly_cleanup_task()

static void reassembly_cleanup_task ( void *  cls)
static

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

Parameters
clsa struct Neighbour

Definition at line 3303 of file gnunet-service-transport.c.

3304{
3305 struct VirtualLink *vl = cls;
3306 struct ReassemblyContext *rc;
3307
3308 vl->reassembly_timeout_task = NULL;
3309 while (NULL != (rc = GNUNET_CONTAINER_heap_peek (vl->reassembly_heap)))
3310 {
3312 .rel_value_us)
3313 {
3315 continue;
3316 }
3321 vl);
3322 return;
3323 }
3324}
static void reassembly_cleanup_task(void *cls)
Task run to clean up reassembly context of a neighbour that have expired.
static void free_reassembly_context(struct ReassemblyContext *rc)
Free rc.
void * GNUNET_CONTAINER_heap_peek(const struct GNUNET_CONTAINER_Heap *heap)
Get element stored at the root of heap.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_at(struct GNUNET_TIME_Absolute at, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run at the specified time.
Definition: scheduler.c:1254
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:406
uint64_t rel_value_us
The actual value.
Information we keep for a message that we are reassembling.
struct GNUNET_TIME_Absolute reassembly_timeout
At what time will we give up reassembly of this message?

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

Referenced by handle_fragment_box(), and reassembly_cleanup_task().

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 3336 of file gnunet-service-transport.c.

3337{
3338 struct ReassemblyContext *rc = value;
3339
3340 (void) cls;
3341 (void) key;
3343 return GNUNET_OK;
3344}
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.

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

Referenced by free_virtual_link().

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

◆ free_virtual_link()

static void free_virtual_link ( struct VirtualLink vl)
static

Free virtual link.

Parameters
vllink data to free

Definition at line 3353 of file gnunet-service-transport.c.

3354{
3355 struct PendingMessage *pm;
3356 struct CoreSentContext *csc;
3357
3359 "free virtual link %p\n",
3360 vl);
3361
3362 if (NULL != vl->reassembly_map)
3363 {
3366 NULL);
3368 vl->reassembly_map = NULL;
3370 vl->reassembly_heap = NULL;
3371 }
3372 if (NULL != vl->reassembly_timeout_task)
3373 {
3376 }
3377 while (NULL != (pm = vl->pending_msg_head))
3381 if (NULL != vl->visibility_task)
3382 {
3384 vl->visibility_task = NULL;
3385 }
3386 if (NULL != vl->fc_retransmit_task)
3387 {
3389 vl->fc_retransmit_task = NULL;
3390 }
3391 while (NULL != (csc = vl->csc_head))
3392 {
3394 GNUNET_assert (vl == csc->vl);
3395 csc->vl = NULL;
3396 }
3397 GNUNET_break (NULL == vl->n);
3398 GNUNET_break (NULL == vl->dv);
3399 GNUNET_free (vl);
3400}
static void free_pending_message(struct PendingMessage *pm)
Release memory associated with pm and remove pm from associated data structures.
static int free_reassembly_cb(void *cls, uint32_t key, void *value)
function called to free_reassembly_context().
static struct GNUNET_CONTAINER_MultiPeerMap * links
Map from PIDs to struct VirtualLink entries describing links CORE knows to exist.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MultiHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
void GNUNET_CONTAINER_heap_destroy(struct GNUNET_CONTAINER_Heap *heap)
Destroys the heap.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
Closure for core_env_sent_cb.
struct VirtualLink * vl
Virtual link this is about.

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

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

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

◆ free_validation_state()

static void free_validation_state ( struct ValidationState vs)
static

Free validation state.

Parameters
vsvalidation state to free

Definition at line 3409 of file gnunet-service-transport.c.

3410{
3411 if (NULL != vs->revalidation_task)
3412 {
3413 GNUNET_SCHEDULER_cancel (vs->revalidation_task);
3414 vs->revalidation_task = NULL;
3415 }
3416 /*memcpy (&hkey,
3417 &hc,
3418 sizeof (hkey));*/
3420 "Remove key %s for address %s map size %u contains %u during freeing state\n",
3421 GNUNET_h2s (&vs->hc),
3422 vs->address,
3425 &vs->hc));
3428 GNUNET_YES ==
3431 vs->hn = NULL;
3432 if (NULL != vs->sc)
3433 {
3435 "store cancel\n");
3437 vs->sc = NULL;
3438 }
3439 GNUNET_free (vs->address);
3440 GNUNET_free (vs);
3441}
static struct GNUNET_CONTAINER_MultiHashMap * revalidation_map
Map from addresses to struct ValidationState entries describing addresses we are aware of and their v...
static struct GNUNET_CONTAINER_MultiPeerMap * validation_map
Map from PIDs to struct ValidationState entries describing addresses we are aware of and their validi...
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
struct GNUNET_PeerIdentity pid
For which peer is address to be validated (or possibly valid)? Serves as key in the validation_map.

References GNUNET_assert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_PEERSTORE_store_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, ValidationState::pid, revalidation_map, and validation_map.

Referenced by free_validation_state_cb(), and validation_start_cb().

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

◆ lookup_neighbour()

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

Lookup neighbour for peer pid.

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

Definition at line 3451 of file gnunet-service-transport.c.

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

References GNUNET_CONTAINER_multipeermap_get(), neighbours, and pid.

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

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

◆ lookup_virtual_link()

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

Lookup virtual link for peer pid.

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

Definition at line 3464 of file gnunet-service-transport.c.

3465{
3467}

References GNUNET_CONTAINER_multipeermap_get(), links, and pid.

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

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

◆ free_distance_vector_hop()

static void free_distance_vector_hop ( struct DistanceVectorHop dvh)
static

Free a dvh.

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

Parameters
dvhhop to free

Definition at line 3513 of file gnunet-service-transport.c.

3514{
3515 struct Neighbour *n = dvh->next_hop;
3516 struct DistanceVector *dv = dvh->dv;
3517 struct PendingAcknowledgement *pa;
3518
3519 while (NULL != (pa = dvh->pa_head))
3520 {
3522 pa->dvh = NULL;
3523 }
3524 GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh);
3526 GNUNET_free (dvh);
3527}
struct Neighbour * next_hop
What would be the next hop to target?
struct DistanceVector * dv
Distance vector entry this hop belongs with.
Entry in our dv_routes table, representing a (set of) distance vector routes to a particular peer.
struct DistanceVectorHop * dv_head
Known paths to target.
struct DistanceVectorHop * dv_tail
Known paths to target.
A neighbour that at least one communicator is connected to.
struct DistanceVectorHop * dv_tail
Tail of MDLL of DV hops that have this neighbour as next hop.
struct DistanceVectorHop * dv_head
Head of MDLL of DV hops that have this neighbour as next hop.

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

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

Here is the caller graph for this function:

◆ check_link_down()

static void check_link_down ( void *  cls)
static

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

Parameters
clsa struct VirtualLink

Definition at line 3952 of file gnunet-service-transport.c.

3953{
3954 struct VirtualLink *vl = cls;
3955 struct DistanceVector *dv = vl->dv;
3956 struct Neighbour *n = vl->n;
3957 struct GNUNET_TIME_Absolute dvh_timeout;
3958 struct GNUNET_TIME_Absolute q_timeout;
3959
3961 "Checking if link is down\n");
3962 vl->visibility_task = NULL;
3963 dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
3964 if (NULL != dv)
3965 {
3966 for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
3967 pos = pos->next_dv)
3968 dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout,
3969 pos->path_valid_until);
3970 if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
3971 {
3972 vl->dv->vl = NULL;
3973 vl->dv = NULL;
3974 }
3975 }
3976 q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
3977 for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
3978 q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
3979 if (0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
3980 {
3981 vl->n->vl = NULL;
3982 vl->n = NULL;
3983 }
3984 if ((NULL == vl->n) && (NULL == vl->dv))
3985 {
3987 free_virtual_link (vl);
3988 return;
3989 }
3990 vl->visibility_task =
3991 GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_max (q_timeout, dvh_timeout),
3993 vl);
3994}
static void cores_send_disconnect_info(const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.
static void free_virtual_link(struct VirtualLink *vl)
Free virtual link.
static void check_link_down(void *cls)
Task run to check whether the hops of the cls still are validated, or if we need to core about discon...
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_max(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the maximum of two absolute time values.
Definition: time.c:368
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
struct DistanceVectorHop * next_dv
Kept in a MDLL, sorted by timeout.
struct VirtualLink * vl
Do we have a confirmed working queue and are thus visible to CORE? If so, this is the virtual link,...
struct VirtualLink * vl
Do we have a confirmed working queue and are thus visible to CORE? If so, this is the virtual link,...
struct Queue * queue_head
Head of DLL of queues to this peer.

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

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

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

◆ cores_send_disconnect_info()

static void cores_send_disconnect_info ( const struct GNUNET_PeerIdentity pid)
static

Send message to CORE clients that we lost a connection.

Parameters
pidpeer the connection was for

Definition at line 3546 of file gnunet-service-transport.c.

3547{
3549 "Informing CORE clients about disconnect from %s\n",
3550 GNUNET_i2s (pid));
3551 for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3552 {
3553 struct GNUNET_MQ_Envelope *env;
3554 struct DisconnectInfoMessage *dim;
3555
3556 if (CT_CORE != tc->type)
3557 continue;
3559 dim->peer = *pid;
3560 GNUNET_MQ_send (tc->mq, env);
3561 }
3562}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
uint32_t dim
Definition: gnunet_pq_lib.h:3
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:305
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:76
#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:120

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

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

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

◆ free_dv_route()

static void free_dv_route ( struct DistanceVector dv)
static

Free entry in dv_routes.

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

Parameters
dvroute to free

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

3573{
3574 struct DistanceVectorHop *dvh;
3575 struct VirtualLink *vl;
3576
3577 while (NULL != (dvh = dv->dv_head))
3579
3581 GNUNET_YES ==
3583 if (NULL != (vl = dv->vl))
3584 {
3585 GNUNET_assert (dv == vl->dv);
3586 vl->dv = NULL;
3587 if (NULL == vl->n)
3588 {
3590 free_virtual_link (vl);
3591 }
3592 else
3593 {
3596 }
3597 dv->vl = NULL;
3598 }
3599
3600 if (NULL != dv->timeout_task)
3601 {
3603 dv->timeout_task = NULL;
3604 }
3605 GNUNET_free (dv->km);
3606 GNUNET_free (dv);
3607}
static void free_distance_vector_hop(struct DistanceVectorHop *dvh)
Free a dvh.
static struct GNUNET_CONTAINER_MultiPeerMap * dv_routes
Map from PIDs to struct DistanceVector entries describing known paths to the peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1304
struct GNUNET_ShortHashCode * km
Master secret for the setup of the Key material for the backchannel.
struct GNUNET_PeerIdentity target
To which peer is this a route?
struct GNUNET_SCHEDULER_Task * timeout_task
Task scheduled to purge expired paths from dv_head MDLL.

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

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

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

◆ notify_monitor()

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

Notify monitor tc about an event.

That tc cares about the event has already been checked.

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

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

Definition at line 3624 of file gnunet-service-transport.c.

3629{
3630 struct GNUNET_MQ_Envelope *env;
3632 size_t addr_len = strlen (address) + 1;
3633
3635 addr_len,
3637 md->nt = htonl ((uint32_t) nt);
3638 md->peer = *peer;
3639 md->last_validation = GNUNET_TIME_absolute_hton (me->last_validation);
3640 md->valid_until = GNUNET_TIME_absolute_hton (me->valid_until);
3641 md->next_validation = GNUNET_TIME_absolute_hton (me->next_validation);
3642 md->rtt = GNUNET_TIME_relative_hton (me->rtt);
3643 md->cs = htonl ((uint32_t) me->cs);
3644 md->num_msg_pending = htonl (me->num_msg_pending);
3645 md->num_bytes_pending = htonl (me->num_bytes_pending);
3646 memcpy (&md[1], address, addr_len);
3647 GNUNET_MQ_send (tc->mq, env);
3648}
static char * address
GNS address for this phone.
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:61
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA
Message sent to indicate to a monitor about events.
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:620
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:640
uint32_t num_msg_pending
Messages pending (in NBO).
Definition: transport.h:766
struct GNUNET_PeerIdentity peer
Target identifier.
Definition: transport.h:744
struct GNUNET_TIME_AbsoluteNBO valid_until
Definition: transport.h:750
struct GNUNET_TIME_AbsoluteNBO last_validation
Definition: transport.h:749
uint32_t num_bytes_pending
Bytes pending (in NBO).
Definition: transport.h:771
struct GNUNET_TIME_AbsoluteNBO next_validation
Definition: transport.h:751
uint32_t nt
Network type (an enum GNUNET_NetworkType in NBO).
Definition: transport.h:739
struct GNUNET_TIME_RelativeNBO rtt
Current round-trip time estimate.
Definition: transport.h:756
uint32_t cs
Connection status (in NBO).
Definition: transport.h:761

References address, GNUNET_TRANSPORT_MonitorData::cs, env, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_hton(), GNUNET_TRANSPORT_MonitorData::last_validation, me, GNUNET_TRANSPORT_MonitorData::next_validation, nt, GNUNET_TRANSPORT_MonitorData::nt, GNUNET_TRANSPORT_MonitorData::num_bytes_pending, GNUNET_TRANSPORT_MonitorData::num_msg_pending, GNUNET_TRANSPORT_MonitorData::peer, GNUNET_TRANSPORT_MonitorData::rtt, tc, and GNUNET_TRANSPORT_MonitorData::valid_until.

Referenced by notify_client_queues(), and notify_monitors().

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

◆ notify_monitors()

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

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

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

Definition at line 3661 of file gnunet-service-transport.c.

3665{
3666 for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3667 {
3668 if (CT_MONITOR != tc->type)
3669 continue;
3670 if (tc->details.monitor.one_shot)
3671 continue;
3672 if ((GNUNET_NO == GNUNET_is_zero (&tc->details.monitor.peer)) &&
3673 (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer)))
3674 continue;
3675 notify_monitor (tc, peer, address, nt, me);
3676 }
3677}
static void notify_monitor(struct TransportClient *tc, const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
Notify monitor tc about an event.
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_NO

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

Referenced by free_queue(), and handle_add_queue_message().

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

◆ client_connect_cb()

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

Called whenever a client connects.

Allocates our data structures associated with that client.

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

Definition at line 3690 of file gnunet-service-transport.c.

3693{
3694 struct TransportClient *tc;
3695
3696 (void) cls;
3697 tc = GNUNET_new (struct TransportClient);
3698 tc->client = client;
3699 tc->mq = mq;
3702 "Client %p of type %u connected\n",
3703 tc,
3704 tc->type);
3705 return tc;
3706}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct TransportClient * clients_tail
Tail of linked list of all clients to this service.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_SERVICE_Client * client
Handle to the client.

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

◆ remove_global_addresses()

static enum GNUNET_GenericReturnValue remove_global_addresses ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Definition at line 3710 of file gnunet-service-transport.c.

3713{
3714 struct TransportGlobalNattedAddress *tgna = value;
3715 (void) cls;
3716
3717 GNUNET_free (tgna);
3718
3719 return GNUNET_OK;
3720}

References GNUNET_free, GNUNET_OK, and value.

Referenced by free_neighbour().

Here is the caller graph for this function:

◆ free_neighbour()

static void free_neighbour ( struct Neighbour neighbour,
enum GNUNET_GenericReturnValue  drop_link 
)
static

Release memory used by neighbour.

Parameters
neighbourneighbour entry to free
drop_linkflag to decide whether to drop its virtual link

Definition at line 3730 of file gnunet-service-transport.c.

3732{
3733 struct DistanceVectorHop *dvh;
3734 struct VirtualLink *vl;
3735
3736 GNUNET_assert (NULL == neighbour->queue_head);
3739 &neighbour->pid,
3740 neighbour));
3742 "Freeing neighbour\n");
3745 NULL);
3747 while (NULL != (dvh = neighbour->dv_head))
3748 {
3749 struct DistanceVector *dv = dvh->dv;
3750
3752 if (NULL == dv->dv_head)
3753 free_dv_route (dv);
3754 }
3755 if (NULL != neighbour->get)
3756 {
3758 neighbour->get = NULL;
3759 }
3760 if (NULL != neighbour->sc)
3761 {
3763 "store cancel\n");
3764 GNUNET_PEERSTORE_store_cancel (neighbour->sc);
3765 neighbour->sc = NULL;
3766 }
3767 if (NULL != (vl = neighbour->vl))
3768 {
3769 GNUNET_assert (neighbour == vl->n);
3770 vl->n = NULL;
3771 if ((GNUNET_YES == drop_link) || (NULL == vl->dv))
3772 {
3775 }
3776 else
3777 {
3780 }
3781 neighbour->vl = NULL;
3782 }
3783 GNUNET_free (neighbour);
3784}
static enum GNUNET_GenericReturnValue remove_global_addresses(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
static void free_dv_route(struct DistanceVector *dv)
Free entry in dv_routes.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_PEERSTORE_iteration_stop(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iteration.
struct GNUNET_CONTAINER_MultiPeerMap * natted_addresses
Map of struct TransportGlobalNattedAddress for this neighbour.
struct GNUNET_PEERSTORE_StoreContext * sc
Handle to a PEERSTORE store operation to store this pid's last_dv_learn_monotime.
struct GNUNET_PeerIdentity pid
Which peer is this about?
struct GNUNET_PEERSTORE_IterateContext * get
Handle for an operation to fetch last_dv_learn_monotime information from the PEERSTORE,...

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

Referenced by free_neighbour_cb(), and free_queue().

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

◆ core_send_connect_info()

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

Send message to CORE clients that we lost a connection.

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

Definition at line 3794 of file gnunet-service-transport.c.

3796{
3797 struct GNUNET_MQ_Envelope *env;
3798 struct ConnectInfoMessage *cim;
3799
3800 GNUNET_assert (CT_CORE == tc->type);
3802 cim->id = *pid;
3803 GNUNET_MQ_send (tc->mq, env);
3804}
#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:88
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:111

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

Referenced by cores_send_connect_info(), and notify_client_connect_info().

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

◆ cores_send_connect_info()

static void cores_send_connect_info ( const struct GNUNET_PeerIdentity pid)
static

Send message to CORE clients that we gained a connection.

Parameters
pidpeer the queue was for

Definition at line 3813 of file gnunet-service-transport.c.

3814{
3816 "Informing CORE clients about connection to %s\n",
3817 GNUNET_i2s (pid));
3818 for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
3819 {
3820 if (CT_CORE != tc->type)
3821 continue;
3823 }
3824}
static void core_send_connect_info(struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we lost a connection.

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

Referenced by activate_core_visible_dv_path(), and handle_validation_response().

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

◆ transmit_on_queue()

static void transmit_on_queue ( void *  cls)
static

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

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

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

Parameters
clsthe struct Queue to process transmissions for

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

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

Parameters
clsthe struct Queue to process transmissions for

Definition at line 10990 of file gnunet-service-transport.c.

10991{
10992 struct Queue *queue = cls;
10993 struct Neighbour *n = queue->neighbour;
10995 struct PendingMessage *pm;
10996
10997 queue->transmit_task = NULL;
10998 if (NULL == n->vl)
10999 {
11001 "Virtual link `%s' is down, cannot have PM for queue `%s'\n",
11002 GNUNET_i2s (&n->pid),
11003 queue->address);
11004 queue->idle = GNUNET_YES;
11005 return;
11006 }
11007 memset (&sc, 0, sizeof(sc));
11008 select_best_pending_from_link (&sc, queue, n->vl, NULL, 0);
11009 if (NULL == sc.best)
11010 {
11011 /* Also look at DVH that have the n as first hop! */
11012 for (struct DistanceVectorHop *dvh = n->dv_head; NULL != dvh;
11013 dvh = dvh->next_neighbour)
11014 {
11016 queue,
11017 dvh->dv->vl,
11018 dvh,
11019 sizeof(struct GNUNET_PeerIdentity)
11020 * (1 + dvh->distance)
11021 + sizeof(struct TransportDVBoxMessage)
11022 + sizeof(struct TransportDVBoxPayloadP));
11023 }
11024 }
11025 if (NULL == sc.best)
11026 {
11027 /* no message pending, nothing to do here! */
11029 "No pending messages, queue `%s' to %s now idle\n",
11030 queue->address,
11031 GNUNET_i2s (&n->pid));
11032 if (GNUNET_YES == sc.to_early)
11033 schedule_transmit_on_queue (sc.to_early_retry_delay,
11034 queue,
11036 queue->idle = GNUNET_YES;
11037 return;
11038 }
11039 /* There is a message pending, we are certainly not idle */
11040 queue->idle = GNUNET_NO;
11041
11042 /* Given selection in `sc`, do transmission */
11043 pm = sc.best;
11045 "Selected message <%" PRIu64 ">\n",
11046 pm->logging_uuid);
11047 if (NULL != sc.dvh)
11048 {
11050 "Is this %u a DV box?\n",
11051 pm->pmt);
11052 GNUNET_assert (PMT_DV_BOX != pm->pmt);
11053 if ((NULL != sc.best->bpm) && (sc.best->bpm->used_dvh != sc.dvh))
11054 {
11056 "Discard old box, because we have a new DV path.\n");
11057 free_pending_message (sc.best->bpm);
11058 sc.best->bpm = NULL;
11059 }
11060
11061 if (NULL == sc.best->bpm)
11062 {
11064 "encapsulate_for_dv 2\n");
11065 encapsulate_for_dv (sc.dvh->dv,
11066 1,
11067 &sc.dvh,
11068 (const struct GNUNET_MessageHeader *) &sc.best[1],
11070 &sc,
11071 RMO_NONE,
11072 GNUNET_NO);
11073 GNUNET_assert (NULL != sc.best->bpm);
11075 "%lu %lu %lu %lu %u\n",
11076 sizeof(struct GNUNET_PeerIdentity),
11077 sizeof(struct TransportDVBoxMessage),
11078 sizeof(struct TransportDVBoxPayloadP),
11079 sizeof(struct TransportFragmentBoxMessage),
11080 ((const struct GNUNET_MessageHeader *) &sc.best[1])->size);
11081 sc.best->bpm->used_dvh = sc.dvh;
11082 }
11083 pm = sc.best->bpm;
11084 }
11085 if (GNUNET_YES == sc.frag)
11086 {
11087 pm = fragment_message (queue, sc.dvh, pm);
11088 if (NULL == pm)
11089 {
11091 "Fragmentation failed queue %s to %s for <%" PRIu64
11092 ">, trying again\n",
11093 queue->address,
11094 GNUNET_i2s (&n->pid),
11095 sc.best->logging_uuid);
11097 queue,
11099 return;
11100 }
11101 }
11102 else if (GNUNET_YES == sc.relb)
11103 {
11105 if (NULL == pm)
11106 {
11107 /* Reliability boxing failed, try next message... */
11108 GNUNET_log (
11110 "Reliability boxing failed queue %s to %s for <%" PRIu64
11111 ">, trying again\n",
11112 queue->address,
11113 GNUNET_i2s (&n->pid),
11114 sc.best->logging_uuid);
11116 queue,
11118 return;
11119 }
11120 }
11121
11122 /* Pass 'pm' for transission to the communicator */
11123 GNUNET_log (
11125 "Passing message <%" PRIu64
11126 "> to queue %s for peer %s (considered %u others)\n",
11127 pm->logging_uuid,
11128 queue->address,
11129 GNUNET_i2s (&n->pid),
11130 sc.consideration_counter);
11131
11132 /* Flow control: increment amount of traffic sent; if we are routing
11133 via DV (and thus the ultimate target of the pending message is for
11134 a different virtual link than the one of the queue), then we need
11135 to use up not only the window of the direct link but also the
11136 flow control window for the DV link! */
11137 pm->vl->outbound_fc_window_size_used += pm->bytes_msg;
11138
11139 if (pm->vl != queue->neighbour->vl)
11140 {
11141 /* If the virtual link of the queue differs, this better be distance
11142 vector routing! */
11143 GNUNET_assert (NULL != sc.dvh);
11144 /* If we do distance vector routing, we better not do this for a
11145 message that was itself DV-routed */
11146 GNUNET_assert (PMT_DV_BOX != sc.best->pmt);
11147 /* We use the size of the unboxed message here, to avoid counting
11148 the DV-Box header which is eaten up on the way by intermediaries */
11149 queue->neighbour->vl->outbound_fc_window_size_used += sc.best->bytes_msg;
11150 }
11151 else
11152 {
11153 GNUNET_assert (NULL == sc.dvh);
11154 }
11155
11156 queue_send_msg (queue, pm, &pm[1], pm->bytes_msg);
11157
11158 /* Check if this transmission somehow conclusively finished handing 'pm'
11159 even without any explicit ACKs */
11160 if ((PMT_CORE == pm->pmt) ||
11161 (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc))
11162 {
11164 }
11165 else
11166 {
11167 struct GNUNET_TIME_Relative wait_duration;
11168 unsigned int wait_multiplier;
11169
11170 if (PMT_FRAGMENT_BOX == pm->pmt)
11171 {
11172 struct PendingMessage *root;
11173
11174 root = pm->frag_parent;
11175 while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
11176 root = root->frag_parent;
11177
11178 wait_multiplier = (unsigned int) ceil ((double) root->bytes_msg
11179 / ((double) root->frag_off
11180 / (double) root->frag_count))
11181 * 4;
11182 }
11183 else
11184 {
11185 // No fragments, we use 4 RTT before retransmitting.
11186 wait_multiplier = 4;
11187 }
11188
11189 // Depending on how much pending message the VirtualLink is queueing, we wait longer.
11190 // wait_multiplier = wait_multiplier * pm->vl->pending_msg_num;
11191
11193 "Wait multiplier %u\n",
11194 wait_multiplier);
11195
11196 /* Message not finished, waiting for acknowledgement.
11197 Update time by which we might retransmit 's' based on queue
11198 characteristics (i.e. RTT); it takes one RTT for the message to
11199 arrive and the ACK to come back in the best case; but the other
11200 side is allowed to delay ACKs by 2 RTTs, so we use 4 RTT before
11201 retransmitting.
11202
11203 OPTIMIZE: Note that in the future this heuristic should likely
11204 be improved further (measure RTT stability, consider message
11205 urgency and size when delaying ACKs, etc.) */
11206
11207 if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
11208 queue->pd.aged_rtt.rel_value_us)
11209 wait_duration = queue->pd.aged_rtt;
11210 else
11211 {
11212 wait_duration = DEFAULT_ACK_WAIT_DURATION;
11213 wait_multiplier = 4;
11214 }
11215 {
11218 wait_duration, wait_multiplier));
11220 wait_duration, wait_multiplier);
11222 "Waiting %s for ACK until %s\n",
11227 GNUNET_TIME_relative_multiply (wait_duration,
11228 wait_multiplier))
11229 );
11230 }
11231 }
11232 /* finally, re-schedule queue transmission task itself */
11234 queue,
11236}
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:87
static void completed_pending_message(struct PendingMessage *pm)
We have completed transmission of pm, remove it from the transmission queues (and if it is a fragment...
static struct PendingMessage * fragment_message(struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
Fragment the given pm to the given mtu.
static void extract_box_cb(void *cls, struct Neighbour *next_hop, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
Function to call to further operate on the now DV encapsulated message hdr, forwarding it via next_ho...
static void select_best_pending_from_link(struct PendingMessageScoreContext *sc, struct Queue *queue, struct VirtualLink *vl, struct DistanceVectorHop *dvh, size_t overhead)
Select the best pending message from vl for transmission via queue.
static void schedule_transmit_on_queue(struct GNUNET_TIME_Relative delay, struct Queue *queue, enum GNUNET_SCHEDULER_Priority p)
Called whenever something changed that might effect when we try to do the next transmission on queue ...
#define DEFAULT_ACK_WAIT_DURATION
Default value for how long we wait for reliability ack.
static struct PendingMessage * reliability_box_message(struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
Reliability-box the given pm.
static struct GNUNET_TIME_Relative encapsulate_for_dv(struct DistanceVector *dv, unsigned int num_dvhs, struct DistanceVectorHop **dvhs, const struct GNUNET_MessageHeader *hdr, DVMessageHandler use, void *use_cls, enum RouteMessageOptions options, enum GNUNET_GenericReturnValue without_fc)
Pick a path of dv under constraints options and schedule transmission of hdr.
static void queue_send_msg(struct Queue *queue, struct PendingMessage *pm, const void *payload, size_t payload_size)
Send the message payload on queue.
static void update_pm_next_attempt(struct PendingMessage *pm, struct GNUNET_TIME_Absolute next_attempt)
Change the value of the next_attempt field of pm to next_attempt and re-order pm in the transmission ...
@ GNUNET_TRANSPORT_CC_RELIABLE
Transmission is reliabile (with ACKs), e.g.
@ GNUNET_SCHEDULER_PRIORITY_DEFAULT
Run with the default priority (normal P2P operations).
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:579
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:316
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:486
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:640
struct DistanceVectorHop * next_neighbour
Kept in a MDLL.
Header for all communications.
The identity of the host (wraps the signing key of the peer).
Time for relative time used by GNUnet, in microseconds.
Context for select_best_pending_from_link().
uint16_t bytes_msg
Size of the original message.
uint16_t frag_off
Offset at which we should generate the next fragment.
Outer layer of an encapsulated message send over multiple hops.
Plaintext of the variable-size payload that is encrypted within a struct TransportBackchannelEncapsul...
Outer layer of an encapsulated fragmented application message.

References PendingMessage::bytes_msg, completed_pending_message(), DEFAULT_ACK_WAIT_DURATION, Neighbour::dv_head, encapsulate_for_dv(), extract_box_cb(), PendingMessage::frag_count, PendingMessage::frag_off, PendingMessage::frag_parent, fragment_message(), free_pending_message(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO, GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_YES, consensus-simulation::int, DistanceVectorHop::next_neighbour, Neighbour::pid, pm, PendingMessage::pmt, PMT_CORE, PMT_DV_BOX, PMT_FRAGMENT_BOX, queue(), queue_send_msg(), reliability_box_message(), RMO_NONE, sc, schedule_transmit_on_queue(), select_best_pending_from_link(), update_pm_next_attempt(), and Neighbour::vl.

Referenced by schedule_transmit_on_queue().

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

◆ check_for_queue_with_higher_prio()

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

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

Definition at line 3842 of file gnunet-service-transport.c.

3843{
3844 for (struct Queue *s = queue_head; NULL != s;
3845 s = s->next_client)
3846 {
3847 if (s->tc->details.communicator.address_prefix !=
3848 queue->tc->details.communicator.address_prefix)
3849 {
3851 "queue address %s qid %u compare with queue: address %s qid %u\n",
3852 queue->address,
3853 queue->qid,
3854 s->address,
3855 s->qid);
3856 if ((s->priority > queue->priority) && (0 < s->q_capacity) &&
3857 (QUEUE_LENGTH_LIMIT > s->queue_length) )
3858 return GNUNET_YES;
3860 "Lower prio\n");
3861 }
3862 }
3863 return GNUNET_NO;
3864}
static struct Queue * queue_head
Head of queue of messages to transmit.
#define QUEUE_LENGTH_LIMIT
How many messages can we have pending for a given queue (queue to a particular peer via a communicato...
struct Queue * next_client
Kept in a MDLL.

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

Referenced by schedule_transmit_on_queue().

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

◆ schedule_transmit_on_queue()

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

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

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

Definition at line 3875 of file gnunet-service-transport.c.

3878{
3880
3881 if (queue->validated_until.abs_value_us < now.abs_value_us)
3882 return;
3884 queue->tc->details.communicator.
3885 queue_head))
3886 return;
3887
3888 if (queue->tc->details.communicator.total_queue_length >=
3890 {
3892 "Transmission on queue %s (QID %u) throttled due to communicator queue limit\n",
3893 queue->address,
3894 queue->qid);
3896 GST_stats,
3897 "# Transmission throttled due to communicator queue limit",
3898 1,
3899 GNUNET_NO);
3900 queue->idle = GNUNET_NO;
3901 return;
3902 }
3903 if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
3904 {
3906 "Transmission on queue %s (QID %u) throttled due to communicator queue length limit\n",
3907 queue->address,
3908 queue->qid);
3910 "# Transmission throttled due to queue queue limit",
3911 1,
3912 GNUNET_NO);
3913 queue->idle = GNUNET_NO;
3914 return;
3915 }
3916 if (0 == queue->q_capacity)
3917 {
3919 "Transmission on queue %s (QID %u) throttled due to communicator message has capacity %"
3920 PRIu64 ".\n",
3921 queue->address,
3922 queue->qid,
3923 queue->q_capacity);
3925 "# Transmission throttled due to message queue capacity",
3926 1,
3927 GNUNET_NO);
3928 queue->idle = GNUNET_NO;
3929 return;
3930 }
3931 /* queue might indeed be ready, schedule it */
3932 if (NULL != queue->transmit_task)
3933 GNUNET_SCHEDULER_cancel (queue->transmit_task);
3934 queue->transmit_task =
3936 queue);
3938 "Considering transmission on queue `%s' QID %llu to %s\n",
3939 queue->address,
3940 (unsigned long long) queue->qid,
3941 GNUNET_i2s (&queue->neighbour->pid));
3942}
static unsigned int check_for_queue_with_higher_prio(struct Queue *queue, struct Queue *queue_head)
Check if the communicator has another queue with higher prio ready for sending.
#define COMMUNICATOR_TOTAL_QUEUE_LIMIT
How many messages can we have pending for a given communicator process before we start to throttle th...
static void transmit_on_queue(void *cls)
We believe we are ready to transmit a message on a queue.
static struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1207
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
uint64_t abs_value_us
The actual value.

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

Referenced by check_vl_transmission(), free_queue(), free_queue_entry(), handle_update_queue_message(), and transmit_on_queue().

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

◆ free_queue()

static void free_queue ( struct Queue queue)
static

Free queue.

Parameters
queuethe queue to free

Definition at line 4003 of file gnunet-service-transport.c.

4004{
4005 struct Neighbour *neighbour = queue->neighbour;
4006 struct TransportClient *tc = queue->tc;
4007 struct MonitorEvent me = { .cs = GNUNET_TRANSPORT_CS_DOWN,
4009 struct QueueEntry *qe;
4010 int maxxed;
4011 struct PendingAcknowledgement *pa;
4012 struct VirtualLink *vl;
4013
4015 "Cleaning up queue %u\n", queue->qid);
4016 if (NULL != queue->mo)
4017 {
4019 queue->mo = NULL;
4020 }
4021 if (NULL != queue->transmit_task)
4022 {
4023 GNUNET_SCHEDULER_cancel (queue->transmit_task);
4024 queue->transmit_task = NULL;
4025 }
4026 while (NULL != (pa = queue->pa_head))
4027 {
4028 GNUNET_CONTAINER_MDLL_remove (queue, queue->pa_head, queue->pa_tail, pa);
4029 pa->queue = NULL;
4030 }
4031
4033 neighbour->queue_head,
4034 neighbour->queue_tail,
4035 queue);
4037 tc->details.communicator.queue_head,
4038 tc->details.communicator.queue_tail,
4039 queue);
4041 tc->details.communicator.total_queue_length);
4043 "Cleaning up queue with length %u\n",
4044 queue->queue_length);
4045 while (NULL != (qe = queue->queue_head))
4046 {
4047 GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe);
4048 queue->queue_length--;
4049 tc->details.communicator.total_queue_length--;
4050 if (NULL != qe->pm)
4051 {
4052 GNUNET_assert (qe == qe->pm->qe);
4053 qe->pm->qe = NULL;
4054 }
4055 GNUNET_free (qe);
4056 }
4057 GNUNET_assert (0 == queue->queue_length);
4058 if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT >
4059 tc->details.communicator.total_queue_length))
4060 {
4061 /* Communicator dropped below threshold, resume all _other_ queues */
4063 GST_stats,
4064 "# Transmission throttled due to communicator queue limit",
4065 -1,
4066 GNUNET_NO);
4067 for (struct Queue *s = tc->details.communicator.queue_head; NULL != s;
4068 s = s->next_client)
4070 s,
4072 }
4073 notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
4075
4076 vl = lookup_virtual_link (&neighbour->pid);
4077 if ((NULL != vl) && (neighbour == vl->n))
4078 {
4080 check_link_down (vl);
4081 }
4082 if (NULL == neighbour->queue_head)
4083 {
4084 free_neighbour (neighbour, GNUNET_NO);
4085 }
4086}
static void free_neighbour(struct Neighbour *neighbour, enum GNUNET_GenericReturnValue drop_link)
Release memory used by neighbour.
static void notify_monitors(const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
Send information in me about a peer's status with respect to some address to all monitors that care.
static struct VirtualLink * lookup_virtual_link(const struct GNUNET_PeerIdentity *pid)
Lookup virtual link for peer pid.
@ GNUNET_TRANSPORT_CS_DOWN
Connection is down.
Details about what to notify monitors about.
struct Queue * queue_tail
Tail of DLL of queues to this peer.

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

Referenced by client_disconnect_cb(), and handle_del_queue_message().

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

◆ free_address_list_entry()

static void free_address_list_entry ( struct AddressListEntry ale)
static

Free ale.

Parameters
aleaddress list entry to free

Definition at line 4095 of file gnunet-service-transport.c.

4096{
4097 struct TransportClient *tc = ale->tc;
4098
4099 GNUNET_CONTAINER_DLL_remove (tc->details.communicator.addr_head,
4100 tc->details.communicator.addr_tail,
4101 ale);
4102 if (NULL != ale->sc)
4103 {
4105 "store cancel\n");
4107 ale->sc = NULL;
4108 }
4109 if (NULL != ale->st)
4110 {
4112 ale->st = NULL;
4113 }
4114 if (NULL != ale->signed_address)
4116 GNUNET_free (ale);
4117}
struct TransportClient * tc
Which communicator provides this address?
void * signed_address
Signed address.
struct GNUNET_SCHEDULER_Task * st
Task to periodically do st operation.
struct GNUNET_PEERSTORE_StoreContext * sc
Current context for storing this address in the peerstore.

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

Referenced by client_disconnect_cb(), and handle_del_address().

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

◆ stop_peer_request()

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

Stop the peer request in value.

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

Definition at line 4129 of file gnunet-service-transport.c.

4132{
4133 struct TransportClient *tc = cls;
4134 struct PeerRequest *pr = value;
4135
4136 if (NULL != pr->nc)
4138 pr->nc = NULL;
4140 GNUNET_YES ==
4141 GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests,
4142 pid,
4143 pr));
4144 GNUNET_free (pr);
4145
4146 return GNUNET_OK;
4147}
Information per peer and request.
struct GSF_PendingRequest * pr
Handle to generic request (generic: from peer or local client).

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

Referenced by client_disconnect_cb(), and handle_suggest_cancel().

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

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Function called when the service shuts down.

Unloads our plugins and cancels pending validations.

Parameters
clsclosure, unused

Definition at line 12875 of file gnunet-service-transport.c.

12876{
12877 struct LearnLaunchEntry *lle;
12878 (void) cls;
12879
12881 "shutdown logic\n");
12884 &free_neighbour_cb, NULL);
12885 if (NULL != validation_task)
12886 {
12888 validation_task = NULL;
12889 }
12890 if (NULL != dvlearn_task)
12891 {
12893 dvlearn_task = NULL;
12894 }
12896 dvlearn_map = NULL;
12898 validation_heap = NULL;
12901 dv_routes = NULL;
12902 if (NULL != GST_stats)
12903 {
12905 GST_stats = NULL;
12906 }
12907 if (NULL != GST_my_hello)
12908 {
12910 GST_my_hello = NULL;
12911 }
12912 if (NULL != GST_my_private_key)
12913 {
12915 GST_my_private_key = NULL;
12916 }
12919 NULL);
12921 ack_cummulators = NULL;
12924 NULL);
12926 pending_acks = NULL;
12929 neighbours = NULL;
12932 links = NULL;
12935 NULL);
12937 backtalkers = NULL;
12940 NULL);
12942 validation_map = NULL;
12944 revalidation_map = NULL;
12945 while (NULL != ir_head)
12947 GNUNET_assert (0 == ir_total);
12948 while (NULL != (lle = lle_head))
12949 {
12951 GNUNET_free (lle);
12952 }
12953 if (NULL != peerstore)
12954 {
12956 "Disconnecting from PEERSTORE service\n");
12958 peerstore = NULL;
12959 }
12961}
static struct GNUNET_SCHEDULER_Task * dvlearn_task
Task run to initiate DV learning.
static struct LearnLaunchEntry * lle_tail
Tail of a DLL sorted by launch time.
static struct GNUNET_CONTAINER_Heap * validation_heap
MIN Heap sorted by "next_challenge" to struct ValidationState entries sorting addresses we are aware ...
static struct LearnLaunchEntry * lle_head
Head of a DLL sorted by launch time.
static int free_pending_ack_cb(void *cls, const struct GNUNET_Uuid *key, void *value)
Free pending acknowledgement.
struct GNUNET_NAT_Handle * nh
Handle for connect to the NAT service.
static struct GNUNET_SCHEDULER_Task * validation_task
Task to run address validation.
static struct GNUNET_CRYPTO_EddsaPrivateKey * GST_my_private_key
Our private key.
static struct GNUNET_PEERSTORE_Handle * peerstore
Database for peer's HELLOs.
static int free_validation_state_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free validation state.
static int free_neighbour_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free neighbour entry.
struct GNUNET_HELLO_Builder * GST_my_hello
Our HELLO.
static struct GNUNET_CONTAINER_MultiShortmap * dvlearn_map
Map from challenges to struct LearnLaunchEntry values.
static struct GNUNET_CONTAINER_MultiPeerMap * backtalkers
Map from PIDs to struct Backtalker entries.
static int free_backtalker_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Callback to free backtalker records.
static struct GNUNET_CONTAINER_MultiPeerMap * ack_cummulators
Map from PIDs to struct AcknowledgementCummulators.
static int free_dv_routes_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free DV route entry.
static int free_ack_cummulator_cb(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Free acknowledgement cummulator.
static void free_incoming_request(struct IncomingRequest *ir)
Release ir data structure.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_CONTAINER_multiuuidmap_destroy(struct GNUNET_CONTAINER_MultiUuidmap *map)
Destroy a hash map.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multiuuidmap_iterate(struct GNUNET_CONTAINER_MultiUuidmap *map, GNUNET_CONTAINER_MultiUuidmapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_HELLO_builder_free(struct GNUNET_HELLO_Builder *builder)
Release resources of a builder.
Definition: hello-uri.c:453
void GNUNET_NAT_unregister(struct GNUNET_NAT_Handle *nh)
Stop port redirection and public IP address detection for the given handle.
Definition: nat_api.c:703
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the PEERSTORE service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:567
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
When did we launch this DV learning activity?

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

Referenced by client_disconnect_cb(), and shutdown_task().

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

◆ client_disconnect_cb()

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

Called whenever a client is disconnected.

Frees our resources associated with that client.

Parameters
clsclosure, NULL
clientidentification of the client
app_ctxour struct TransportClient

Definition at line 4162 of file gnunet-service-transport.c.

4165{
4166 struct TransportClient *tc = app_ctx;
4167
4168 (void) cls;
4169 (void) client;
4171 switch (tc->type)
4172 {
4173 case CT_NONE:
4175 "Unknown Client %p disconnected, cleaning up.\n",
4176 tc);
4177 break;
4178
4179 case CT_CORE: {
4180 struct PendingMessage *pm;
4182 "CORE Client %p disconnected, cleaning up.\n",
4183 tc);
4184
4185
4186 while (NULL != (pm = tc->details.core.pending_msg_head))
4187 {
4189 tc->details.core.pending_msg_head,
4190 tc->details.core.pending_msg_tail,
4191 pm);
4192 pm->client = NULL;
4193 }
4194 }
4195 break;
4196
4197 case CT_MONITOR:
4199 "MONITOR Client %p disconnected, cleaning up.\n",
4200 tc);
4201
4202 break;
4203
4204 case CT_COMMUNICATOR: {
4205 struct Queue *q;
4206 struct AddressListEntry *ale;
4207
4209 "COMMUNICATOR Client %p disconnected, cleaning up.\n",
4210 tc);
4211
4212 if (NULL != tc->details.communicator.free_queue_entry_task)
4214 tc->details.communicator.free_queue_entry_task);
4215 while (NULL != (q = tc->details.communicator.queue_head))
4216 free_queue (q);
4217 while (NULL != (ale = tc->details.communicator.addr_head))
4219 GNUNET_free (tc->details.communicator.address_prefix);
4220 }
4221 break;
4222
4223 case CT_APPLICATION:
4225 "APPLICATION Client %p disconnected, cleaning up.\n",
4226 tc);
4227
4228 GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests,
4230 tc);
4231 GNUNET_CONTAINER_multipeermap_destroy (tc->details.application.requests);
4232 break;
4233 }
4234 GNUNET_free (tc);
4235 if ((GNUNET_YES == in_shutdown) && (NULL == clients_head))
4236 {
4238 "Our last client disconnected\n");
4239 do_shutdown (cls);
4240 }
4241}
static void free_queue(struct Queue *queue)
Free queue.
static int stop_peer_request(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Stop the peer request in value.
static int in_shutdown
Indication if we have received a shutdown signal and are in the process of cleaning up.
static void do_shutdown(void *cls)
Function called when the service shuts down.
static void free_address_list_entry(struct AddressListEntry *ale)
Free ale.
@ GNUNET_ERROR_TYPE_ERROR
One of the addresses of this peer.
struct TransportClient * client
Client that issued the transmission request, if pmt is PMT_CORE.

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

Here is the call graph for this function:

◆ notify_client_connect_info()

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

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

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

Definition at line 4254 of file gnunet-service-transport.c.

4257{
4258 struct TransportClient *tc = cls;
4259 struct VirtualLink *vl = value;
4260
4261 if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
4262 return GNUNET_OK;
4263
4265 "Telling new CORE client about existing connection to %s\n",
4266 GNUNET_i2s (pid));
4268 return GNUNET_OK;
4269}

References VirtualLink::confirmed, core_send_connect_info(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, pid, tc, and value.

Referenced by handle_client_start().

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

◆ finish_cmc_handling_with_continue()

static void finish_cmc_handling_with_continue ( struct CommunicatorMessageContext cmc,
unsigned int  free_cmc 
)
static

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

Parameters
cmccontext for which we are done handling the message

Definition at line 4523 of file gnunet-service-transport.c.

4526{
4527 if (0 != ntohl (cmc->im.fc_on))
4528 {
4529 /* send ACK when done to communicator for flow control! */
4530 struct GNUNET_MQ_Envelope *env;
4532
4534 "Acknowledge message with flow control id %" PRIu64 "\n",
4535 cmc->im.fc_id);
4537 ack->reserved = htonl (0);
4538 ack->fc_id = cmc->im.fc_id;
4539 ack->sender = cmc->im.neighbour_sender;
4540 GNUNET_MQ_send (cmc->tc->mq, env);
4541 }
4542
4544
4545 if (GNUNET_YES == free_cmc)
4546 {
4547 GNUNET_free (cmc);
4548 }
4549}
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK
transport acknowledges processing an incoming message
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2389
struct GNUNET_TRANSPORT_IncomingMessage im
Additional information for flow control and about the sender.
struct TransportClient * tc
Which communicator provided us with the message.
Transport informs us about being done with an incoming message.
Definition: transport.h:374
struct GNUNET_PeerIdentity sender
Sender identifier of the original message.
Definition: transport.h:393
uint64_t fc_id
Which message is being ACKed?
Definition: transport.h:388
uint32_t reserved
Reserved (0)
Definition: transport.h:383
struct GNUNET_PeerIdentity neighbour_sender
Direct neighbour sender identifier.
Definition: transport.h:363
uint32_t fc_on
Do we use flow control or not?
Definition: transport.h:342
uint64_t fc_id
64-bit number to identify the matching ACK.
Definition: transport.h:347
struct GNUNET_MQ_Handle * mq
Message queue to the client.

References TransportClient::client, env, GNUNET_TRANSPORT_IncomingMessage::fc_id, GNUNET_TRANSPORT_IncomingMessageAck::fc_id, GNUNET_TRANSPORT_IncomingMessage::fc_on, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_YES, CommunicatorMessageContext::im, TransportClient::mq, GNUNET_TRANSPORT_IncomingMessage::neighbour_sender, GNUNET_TRANSPORT_IncomingMessageAck::reserved, GNUNET_TRANSPORT_IncomingMessageAck::sender, and CommunicatorMessageContext::tc.

Referenced by finish_cmc_handling(), finish_handling_raw_message(), handle_client_recv_ok(), handle_raw_message(), and resume_communicators().

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

◆ resume_communicators()

static enum GNUNET_GenericReturnValue resume_communicators ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Definition at line 4283 of file gnunet-service-transport.c.

4286{
4287 struct VirtualLink *vl = value;
4288 struct CommunicatorMessageContext *cmc;
4289
4290 /* resume communicators */
4291 while (NULL != (cmc = vl->cmc_tail))
4292 {
4294 if (GNUNET_NO == cmc->continue_send)
4296 }
4297 return GNUNET_OK;
4298}
static void finish_cmc_handling_with_continue(struct CommunicatorMessageContext *cmc, unsigned int free_cmc)
Send ACK to communicator (if requested) and free cmc.
Context from handle_incoming_msg().
unsigned int continue_send
Did we already call GNUNET_SERVICE_client_continue and send ACK to communicator?

References VirtualLink::cmc_head, VirtualLink::cmc_tail, CommunicatorMessageContext::continue_send, finish_cmc_handling_with_continue(), GNUNET_CONTAINER_DLL_remove, GNUNET_NO, GNUNET_OK, GNUNET_YES, and value.

Referenced by handle_client_start().

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

◆ handle_client_start()

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

Initialize a "CORE" client.

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

Parameters
clsthe client
startthe start message that was sent

Definition at line 4310 of file gnunet-service-transport.c.

4311{
4312 struct TransportClient *tc = cls;
4313 uint32_t options;
4314
4315 options = ntohl (start->options);
4316 if ((0 != (1 & options)) &&
4317 (0 != GNUNET_memcmp (&start->self, &GST_my_identity)))
4318 {
4319 /* client thinks this is a different peer, reject */
4320 GNUNET_break (0);
4322 return;
4323 }
4324 if (CT_NONE != tc->type)
4325 {
4326 GNUNET_break (0);
4328 return;
4329 }
4330 tc->type = CT_CORE;
4332 "New CORE client with PID %s registered\n",
4333 GNUNET_i2s (&start->self));
4336 tc);
4339 NULL);
4341}
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:38
static struct GNUNET_PeerIdentity GST_my_identity
Our public key.
static enum GNUNET_GenericReturnValue resume_communicators(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
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:2418

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

Here is the call graph for this function:

◆ check_client_send()

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

Client asked for transmission to a peer.

Process the request.

Parameters
clsthe client
obmthe send message that was sent

Definition at line 4351 of file gnunet-service-transport.c.

4352{
4353 struct TransportClient *tc = cls;
4354 uint16_t size;
4355 const struct GNUNET_MessageHeader *obmm;
4356
4357 if (CT_CORE != tc->type)
4358 {
4359 GNUNET_break (0);
4360 return GNUNET_SYSERR;
4361 }
4362 size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
4363 if (size < sizeof(struct GNUNET_MessageHeader))
4364 {
4365 GNUNET_break (0);
4366 return GNUNET_SYSERR;
4367 }
4368 obmm = (const struct GNUNET_MessageHeader *) &obm[1];
4369 if (size != ntohs (obmm->size))
4370 {
4371 GNUNET_break (0);
4372 return GNUNET_SYSERR;
4373 }
4374 return GNUNET_OK;
4375}
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SYSERR
static unsigned int size
Size of the "table".
Definition: peer.c:68
Message used to notify the transport service about a message to be transmitted to another peer.
Definition: transport.h:229
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND.
Definition: transport.h:233

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

◆ client_send_response()

static void client_send_response ( struct PendingMessage pm)
static

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

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

Parameters
pmhandle to the original pending message

Definition at line 4386 of file gnunet-service-transport.c.

4387{
4388 struct TransportClient *tc = pm->client;
4389 struct VirtualLink *vl = pm->vl;
4390
4392 "client send response\n");
4393 if (NULL != tc)
4394 {
4395 struct GNUNET_MQ_Envelope *env;
4396 struct SendOkMessage *so_msg;
4397
4399 so_msg->peer = vl->target;
4401 "Confirming transmission of <%" PRIu64 "> to %s\n",
4402 pm->logging_uuid,
4403 GNUNET_i2s (&vl->target));
4404 GNUNET_MQ_send (tc->mq, env);
4405 }
4407}
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
Confirmation from TRANSPORT that message for transmission has been queued (and that the next message ...
Message used to notify the transport API that it can send another message to the transport service.
Definition: transport.h:161
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:195

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

Referenced by completed_pending_message(), and reliability_box_message().

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

◆ pick_random_dv_hops()

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

Pick hops_array_length random DV paths satisfying options.

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

Definition at line 4420 of file gnunet-service-transport.c.

4424{
4425 uint64_t choices[hops_array_length];
4426 uint64_t num_dv;
4427 unsigned int dv_count;
4428
4429 /* Pick random vectors, but weighted by distance, giving more weight
4430 to shorter vectors */
4431 num_dv = 0;
4432 dv_count = 0;
4433 for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
4434 pos = pos->next_dv)
4435 {
4436 if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
4437 (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
4438 .rel_value_us == 0))
4439 continue; /* pos unconfirmed and confirmed required */
4440 num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
4441 dv_count++;
4442 }
4443 if (0 == dv_count)
4444 return 0;
4445 if (dv_count <= hops_array_length)
4446 {
4447 dv_count = 0;
4448 for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
4449 pos = pos->next_dv)
4450 hops_array[dv_count++] = pos;
4451 return dv_count;
4452 }
4453 for (unsigned int i = 0; i < hops_array_length; i++)
4454 {
4455 int ok = GNUNET_NO;
4456 while (GNUNET_NO == ok)
4457 {
4458 choices[i] =
4460 ok = GNUNET_YES;
4461 for (unsigned int j = 0; j < i; j++)
4462 if (choices[i] == choices[j])
4463 {
4464 ok = GNUNET_NO;
4465 break;
4466 }
4467 }
4468 }
4469 dv_count = 0;
4470 num_dv = 0;
4471 for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
4472 pos = pos->next_dv)
4473 {
4474 uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance;
4475
4476 if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
4477 (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
4478 .rel_value_us == 0))
4479 continue; /* pos unconfirmed and confirmed required */
4480 for (unsigned int i = 0; i < hops_array_length; i++)
4481 if ((num_dv <= choices[i]) && (num_dv + delta > choices[i]))
4482 hops_array[dv_count++] = pos;
4483 num_dv += delta;
4484 }
4485 return dv_count;
4486}
#define MAX_DV_HOPS_ALLOWED
Maximum DV distance allowed ever.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36

References warningfilter::choices, 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, options, GNUNET_TIME_Relative::rel_value_us, and RMO_UNCONFIRMED_ALLOWED.

Referenced by route_control_message_without_fc().

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 4496 of file gnunet-service-transport.c.

4499{
4500 struct TransportClient *tc = cls;
4501 uint16_t size;
4502
4503 if (CT_NONE != tc->type)
4504 {
4505 GNUNET_break (0);
4506 return GNUNET_SYSERR;
4507 }
4508 tc->type = CT_COMMUNICATOR;
4509 size = ntohs (cam->header.size) - sizeof(*cam);
4510 if (0 == size)
4511 return GNUNET_OK; /* receive-only communicator */
4513 return GNUNET_OK;
4514}
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR.
Definition: transport.h:267

References CT_COMMUNICATOR, CT_NONE, GNUNET_break, GNUNET_MQ_check_zero_termination, GNUNET_OK, GNUNET_SYSERR, GNUNET_TRANSPORT_CommunicatorAvailableMessage::header, GNUNET_MessageHeader::size, size, and tc.

◆ finish_cmc_handling()

static void finish_cmc_handling ( struct CommunicatorMessageContext cmc)
static

Definition at line 4553 of file gnunet-service-transport.c.

References finish_cmc_handling_with_continue(), and GNUNET_YES.

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

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

◆ handle_client_recv_ok()

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

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

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

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

Parameters
clsthe client
romthe message that was sent

Definition at line 4569 of file gnunet-service-transport.c.

4570{
4571 struct TransportClient *tc = cls;
4572 struct VirtualLink *vl;
4573 uint32_t delta;
4574 struct CommunicatorMessageContext *cmc;
4575
4576 if (CT_CORE != tc->type)
4577 {
4578 GNUNET_break (0);
4580 return;
4581 }
4582 vl = lookup_virtual_link (&rom->peer);
4583 if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
4584 {
4586 "# RECV_OK dropped: virtual link unknown",
4587 1,
4588 GNUNET_NO);
4590 return;
4591 }
4592 delta = ntohl (rom->increase_window_delta);
4593 vl->core_recv_window += delta;
4595 "CORE ack receiving message, increased CORE recv window to %d\n",
4596 vl->core_recv_window);
4598 if (vl->core_recv_window <= 0)
4599 return;
4600 /* resume communicators */
4601 while (NULL != (cmc = vl->cmc_tail))
4602 {
4604 if (GNUNET_NO == cmc->continue_send)
4606 }
4607}
struct GNUNET_PeerIdentity peer
Which peer can CORE handle more from now?
Definition: transport.h:220
uint32_t increase_window_delta
Number of messages by which to increase the window, greater or equal to one.
Definition: transport.h:215

References VirtualLink::cmc_head, VirtualLink::cmc_tail, VirtualLink::confirmed, CommunicatorMessageContext::continue_send, VirtualLink::core_recv_window, CT_CORE, delta, finish_cmc_handling_with_continue(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GNUNET_YES, GST_stats, RecvOkMessage::increase_window_delta, lookup_virtual_link(), RecvOkMessage::peer, and tc.

Here is the call graph for this function:

◆ handle_communicator_available()

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

Communicator started.

Process the request.

Parameters
clsthe client
camthe send message that was sent

Definition at line 4617 of file gnunet-service-transport.c.

4620{
4621 struct TransportClient *tc = cls;
4622 uint16_t size;
4623
4624 size = ntohs (cam->header.size) - sizeof(*cam);
4625 if (0 == size)
4626 {
4628 "Receive-only communicator connected\n");
4629 return; /* receive-only communicator */
4630 }
4631 tc->details.communicator.address_prefix =
4632 GNUNET_strdup ((const char *) &cam[1]);
4633 tc->details.communicator.cc = ntohl (cam->cc);
4634 tc->details.communicator.can_burst = ntohl (cam->can_burst);
4636 "Communicator for peer %s with prefix '%s' connected %s\n",
4638 tc->details.communicator.address_prefix,
4639 tc->details.communicator.can_burst ? "can burst" :
4640 "can not burst");
4642}
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
uint32_t cc
NBO encoding of enum GNUNET_TRANSPORT_CommunicatorCharacteristics
Definition: transport.h:272
uint32_t can_burst
The communicator can do burst msgs.
Definition: transport.h:277

References GNUNET_TRANSPORT_CommunicatorAvailableMessage::can_burst, GNUNET_TRANSPORT_CommunicatorAvailableMessage::cc, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GST_my_identity, GNUNET_TRANSPORT_CommunicatorAvailableMessage::header, GNUNET_MessageHeader::size, size, and tc.

Here is the call graph for this function:

◆ check_communicator_backchannel()

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

Communicator requests backchannel transmission.

Check the request.

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

Definition at line 4653 of file gnunet-service-transport.c.

4656{
4657 const struct GNUNET_MessageHeader *inbox;
4658 const char *is;
4659 uint16_t msize;
4660 uint16_t isize;
4661
4662 (void) cls;
4663 msize = ntohs (cb->header.size) - sizeof(*cb);
4664 inbox = (const struct GNUNET_MessageHeader *) &cb[1];
4665 isize = ntohs (inbox->size);
4666 if (isize >= msize)
4667 {
4668 GNUNET_break (0);
4669 return GNUNET_SYSERR;
4670 }
4671 is = (const char *) inbox;
4672 is += isize;
4673 msize -= isize;
4674 GNUNET_assert (0 < msize);
4675 if ('\0' != is[msize - 1])
4676 {
4677 GNUNET_break (0);
4678 return GNUNET_SYSERR;
4679 }
4680 return GNUNET_OK;
4681}
static struct GNUNET_TESTING_Interpreter * is
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL.
Definition: transport.h:630

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

◆ sign_ephemeral()

static void sign_ephemeral ( struct DistanceVector dv)
static

Sign ephemeral keys in our dv are current.

Parameters
[in,out]dvvirtual link to update ephemeral for

Definition at line 4690 of file gnunet-service-transport.c.

4691{
4692 struct EphemeralConfirmationPS ec;
4693
4695 dv->ephemeral_validity =
4697 ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
4698 ec.target = dv->target;
4699 ec.ephemeral_key = dv->ephemeral_key;
4700 ec.sender_monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
4701 ec.purpose.size = htonl (sizeof(ec));
4703 &ec,
4704 &dv->sender_sig);
4705}
#define EPHEMERAL_VALIDITY
How long are ephemeral keys valid?
static const struct GNUNET_CONFIGURATION_Handle * GST_cfg
Configuration handle.
#define GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL
Signature by a peer affirming that the given ephemeral key is currently in use by that peer's transpo...
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
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:452
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:864
struct GNUNET_TIME_Absolute monotime
What time was sender_sig created.
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Signature affirming ephemeral_key of type GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL.
struct GNUNET_CRYPTO_HpkeEncapsulation ephemeral_key
Our ephemeral key.
struct GNUNET_TIME_Absolute ephemeral_validity
How long is sender_sig valid.
Body by which a peer confirms that it is using an ephemeral key.

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

Referenced by encapsulate_for_dv().

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

◆ free_queue_entry()

static void free_queue_entry ( struct QueueEntry qe,
struct TransportClient tc 
)
static

Definition at line 11279 of file gnunet-service-transport.c.

11281{
11282 struct PendingMessage *pm;
11283
11284 GNUNET_CONTAINER_DLL_remove (qe->queue->queue_head,
11285 qe->queue->queue_tail,
11286 qe);
11287 qe->queue->queue_length--;
11288 tc->details.communicator.total_queue_length--;
11290 "Received ACK on queue %s (QID %u) to peer %s (new length: %u/%u)\n",
11291 qe->queue->address,
11292 qe->queue->qid,
11293 GNUNET_i2s (&qe->queue->neighbour->pid),
11294 qe->queue->queue_length,
11295 tc->details.communicator.total_queue_length);
11296
11297 /* if applicable, resume transmissions that waited on ACK */
11299 tc->details.communicator.total_queue_length)
11300 {
11301 /* Communicator dropped below threshold, resume all queues
11302 incident with this client! */
11304 GST_stats,
11305 "# Transmission throttled due to communicator queue limit",
11306 -1,
11307 GNUNET_NO);
11308 for (struct Queue *queue = tc->details.communicator.queue_head;
11309 NULL != queue;
11310 queue = queue->next_client)
11311 {
11313 queue,
11315 }
11316 }
11317 else if (QUEUE_LENGTH_LIMIT - 1 == qe->queue->queue_length)
11318 {
11319 /* queue dropped below threshold; only resume this one queue */
11321 "# Transmission throttled due to queue queue limit",
11322 -1,
11323 GNUNET_NO);
11325 qe->queue,
11327 }
11328 else if (1 == qe->queue->q_capacity)
11329 {
11330 // TODO I guess this will never happen, because the communicator triggers this by updating its queue length itself.
11332 "Transmission rescheduled due to communicator message queue with qid %u has capacity %"
11333 PRIu64 ".\n",
11334 qe->queue->qid,
11335 qe->queue->q_capacity);
11336 /* message queue has capacity; only resume this one queue */
11337 /* queue dropped below threshold; only resume this one queue */
11339 "# Transmission throttled due to message queue capacity",
11340 -1,
11341 GNUNET_NO);
11343 qe->queue,
11345 }
11346
11347 if (NULL != (pm = qe->pm))
11348 {
11349 struct VirtualLink *vl;
11350
11351 // GNUNET_assert (qe == pm->qe);
11352 pm->qe = NULL;
11353 /* If waiting for this communicator may have blocked transmission
11354 of pm on other queues for this neighbour, force schedule
11355 transmit on queue for queues of the neighbour */
11356 if (NULL == pm->frag_parent)
11357 {
11358 vl = pm->vl;
11359 if ((NULL != vl) &&
11360 (NULL != vl->pending_msg_head) &&
11361 (vl->pending_msg_head == pm))
11363 }
11364 }
11365 GNUNET_free (qe);
11366}
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.

References check_vl_transmission(), COMMUNICATOR_TOTAL_QUEUE_LIMIT, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_ZERO, GST_stats, VirtualLink::pending_msg_head, pm, qe, queue(), QUEUE_LENGTH_LIMIT, schedule_transmit_on_queue(), and tc.

Referenced by free_timedout_queue_entry(), and handle_send_message_ack().

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

◆ free_timedout_queue_entry()

static void free_timedout_queue_entry ( void *  cls)
static

Definition at line 4714 of file gnunet-service-transport.c.

4715{
4716 struct TransportClient *tc = cls;
4718
4720 "freeing timedout queue entries\n");
4721
4722 tc->details.communicator.free_queue_entry_task = NULL;
4723 for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
4724 queue = queue->next_client)
4725 {
4726 struct QueueEntry *qep = queue->queue_head;
4727
4729 "checking QID %u for timedout queue entries\n",
4730 queue->qid);
4731 while (NULL != qep)
4732 {
4733 struct QueueEntry *pos = qep;
4735 pos->creation_timestamp, now);
4736 qep = qep->next;
4737
4739 "diff to now %s \n",
4742 {
4744 "Freeing timed out QueueEntry with MID %" PRIu64
4745 " and QID %u\n",
4746 pos->mid,
4747 queue->qid);
4748 free_queue_entry (pos, tc);
4749 }
4750 }
4751 }
4752}
#define QUEUE_ENTRY_TIMEOUT
static void free_queue_entry(struct QueueEntry *qe, struct TransportClient *tc)
const char * GNUNET_TIME_relative2s(struct GNUNET_TIME_Relative delta, bool do_round)
Give relative time in human-readable fancy format.
Definition: time.c:264
#define GNUNET_TIME_relative_cmp(t1, op, t2)
Compare two relative times.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition: time.c:423
struct QueueEntry * next
Kept as a DLL.
struct GNUNET_TIME_Absolute creation_timestamp
Timestamp this QueueEntry was created.
uint64_t mid
Message ID used for this message with the queue used for transmission.

References QueueEntry::creation_timestamp, free_queue_entry(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_relative2s(), GNUNET_TIME_relative_cmp, QueueEntry::mid, QueueEntry::next, queue(), QUEUE_ENTRY_TIMEOUT, and tc.

Referenced by queue_send_msg().

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 4765 of file gnunet-service-transport.c.

4769{
4770 struct Neighbour *n = queue->neighbour;
4772 struct GNUNET_MQ_Envelope *env;
4773 struct PendingAcknowledgement *pa;
4774
4775 GNUNET_log (
4777 "Queueing %u bytes of payload for transmission <%" PRIu64
4778 "> on queue %llu to %s\n",
4779 (unsigned int) payload_size,
4780 (NULL == pm) ? 0 : pm->logging_uuid,
4781 (unsigned long long) queue->qid,
4782 GNUNET_i2s (&queue->neighbour->pid));
4783 env = GNUNET_MQ_msg_extra (smt,
4784 payload_size,
4786 smt->qid = htonl (queue->qid);
4787 smt->mid = GNUNET_htonll (queue->mid_gen);
4788 smt->receiver = n->pid;
4789 memcpy (&smt[1], payload, payload_size);
4790 {
4791 /* Pass the env to the communicator of queue for transmission. */
4792 struct QueueEntry *qe;
4793
4794 qe = GNUNET_new (struct QueueEntry);
4795 qe->creation_timestamp = GNUNET_TIME_absolute_get ();
4796 qe->mid = queue->mid_gen;
4798 "Create QueueEntry with MID %" PRIu64
4799 " and QID %u and prefix %s\n",
4800 qe->mid,
4801 queue->qid,
4802 queue->tc->details.communicator.address_prefix);
4803 queue->mid_gen++;
4804 qe->queue = queue;
4805 if (NULL != pm)
4806 {
4807 qe->pm = pm;
4808 // TODO Why do we have a retransmission. When we know, make decision if we still want this.
4809 // GNUNET_assert (NULL == pm->qe);
4810 if (NULL != pm->qe)
4811 {
4813 "Retransmitting message <%" PRIu64
4814 "> remove pm from qe with MID: %llu \n",
4815 pm->logging_uuid,
4816 (unsigned long long) pm->qe->mid);
4817 pm->qe->pm = NULL;
4818 }
4819 pm->qe = qe;
4820 }
4821 GNUNET_assert (CT_COMMUNICATOR == queue->tc->type);
4822 if (0 == queue->q_capacity)
4823 {
4824 // Messages without FC or fragments can get here.
4825 if (NULL != pm)
4826 {
4828 "Message %" PRIu64
4829 " (pm type %u) was not send because queue has no capacity.\n",
4830 pm->logging_uuid,
4831 pm->pmt);
4832 pm->qe = NULL;
4833 }
4834 GNUNET_free (env);
4835 GNUNET_free (qe);
4836 return;
4837 }
4838 GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe);
4839 queue->queue_length++;
4840 queue->tc->details.communicator.total_queue_length++;
4841 if (GNUNET_NO == queue->unlimited_length)
4842 queue->q_capacity--;
4844 "Queue %s with qid %u has capacity %" PRIu64 "\n",
4845 queue->address,
4846 queue->qid,
4847 queue->q_capacity);
4849 queue->tc->details.communicator.total_queue_length)
4850 queue->idle = GNUNET_NO;
4851 if (QUEUE_LENGTH_LIMIT == queue->queue_length)
4852 queue->idle = GNUNET_NO;
4853 if (0 == queue->q_capacity)
4854 queue->idle = GNUNET_NO;
4855
4856 if (GNUNET_NO == queue->idle)
4857 {
4858 struct TransportClient *tc = queue->tc;
4859
4860 if (NULL == tc->details.communicator.free_queue_entry_task)
4861 tc->details.communicator.free_queue_entry_task =
4863 &
4865 tc);
4866 }
4867 if (NULL != pm && NULL != (pa = pm->pa_head))
4868 {
4869 while (pm != pa->pm)
4870 pa = pa->next_pa;
4871 pa->num_send++;
4872 }
4873 // GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value);
4875 "Sending message MID %" PRIu64
4876 " of type %u (%u) and size %lu with MQ %p queue %s (QID %u) pending %"
4877 PRIu64 "\n",
4878 GNUNET_ntohll (smt->mid),
4879 ntohs (((const struct GNUNET_MessageHeader *) payload)->type),
4880 ntohs (smt->header.size),
4881 (unsigned long) payload_size,
4882 queue->tc->mq,
4883 queue->address,
4884 queue->qid,
4885 (NULL == pm) ? 0 : pm->logging_uuid);
4886 GNUNET_MQ_send (queue->tc->mq, env);
4887 }
4888}
static uint32_t type
Type string converted to DNS type value.
static unsigned long long payload
How much data are we currently storing in the database?
static void free_timedout_queue_entry(void *cls)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG
transport tells communicator it wants to transmit
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1277
#define GNUNET_TIME_UNIT_SECONDS
One second.
Inform communicator about transport's desire to send a message.
Definition: transport.h:563
uint32_t qid
Which queue should we use?
Definition: transport.h:572
uint64_t mid
Message ID, used for flow control.
Definition: transport.h:577
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG.
Definition: transport.h:567
struct GNUNET_PeerIdentity receiver
Receiver identifier.
Definition: transport.h:582
unsigned int num_send
How often the PendingMessage was send via the Queue of this PendingAcknowledgement.

References COMMUNICATOR_TOTAL_QUEUE_LIMIT, CT_COMMUNICATOR, env, free_timedout_queue_entry(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_htonll(), GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TRANSPORT_SendMessageTo::header, GNUNET_TRANSPORT_SendMessageTo::mid, PendingAcknowledgement::next_pa, PendingAcknowledgement::num_send, payload, Neighbour::pid, PendingAcknowledgement::pm, pm, qe, GNUNET_TRANSPORT_SendMessageTo::qid, queue(), QUEUE_LENGTH_LIMIT, GNUNET_TRANSPORT_SendMessageTo::receiver, GNUNET_MessageHeader::size, tc, and type.

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

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

◆ route_via_neighbour()

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

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

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

Definition at line 4902 of file gnunet-service-transport.c.

4905{
4906 struct GNUNET_TIME_Absolute now;
4907 unsigned int candidates;
4908 unsigned int sel1;
4909 unsigned int sel2;
4910 struct GNUNET_TIME_Relative rtt;
4911
4912 /* Pick one or two 'random' queues from n (under constraints of options) */
4913 now = GNUNET_TIME_absolute_get ();
4914 /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to
4915 weight in the future; weight could be assigned by observed
4916 bandwidth (note: not sure if we should do this for this type
4917 of control traffic though). */
4918 candidates = 0;
4919 for (struct Queue *pos = n->queue_head; NULL != pos;
4920 pos = pos->next_neighbour)
4921 {
4922 if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
4923 (pos->validated_until.abs_value_us > now.abs_value_us))
4924 candidates++;
4925 }
4926 if (0 == candidates)
4927 {
4928 /* This can happen rarely if the last confirmed queue timed
4929 out just as we were beginning to process this message. */
4931 "Could not route message of type %u to %s: no valid queue\n",
4932 ntohs (hdr->type),
4933 GNUNET_i2s (&n->pid));
4935 "# route selection failed (all no valid queue)",
4936 1,
4937 GNUNET_NO);
4939 }
4940
4943 if (0 == (options & RMO_REDUNDANT))
4944 sel2 = candidates; /* picks none! */
4945 else
4947 candidates = 0;
4948 for (struct Queue *pos = n->queue_head; NULL != pos;
4949 pos = pos->next_neighbour)
4950 {
4951 if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
4952 (pos->validated_until.abs_value_us > now.abs_value_us))
4953 {
4954 if ((sel1 == candidates) || (sel2 == candidates))
4955 {
4957 "Routing message of type %u to %s using %s (#%u)\n",
4958 ntohs (hdr->type),
4959 GNUNET_i2s (&n->pid),
4960 pos->address,
4961 (sel1 == candidates) ? 1 : 2);
4962 rtt = GNUNET_TIME_relative_min (rtt, pos->pd.aged_rtt);
4963 queue_send_msg (pos, NULL, hdr, ntohs (hdr->size));
4964 }
4965 candidates++;
4966 }
4967 }
4968 return rtt;
4969}
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
@ GNUNET_ERROR_TYPE_INFO
struct GNUNET_TIME_Relative GNUNET_TIME_relative_min(struct GNUNET_TIME_Relative t1, struct GNUNET_TIME_Relative t2)
Return the minimum of two relative time values.
Definition: time.c:344
struct Queue * next_neighbour
Kept in a MDLL.

References GNUNET_TIME_Absolute::abs_value_us, 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, GST_stats, options, queue_send_msg(), RMO_REDUNDANT, RMO_UNCONFIRMED_ALLOWED, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

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

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_ShortHashCode 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
[out]keysymmetric cipher and HMAC state to generate

Definition at line 5014 of file gnunet-service-transport.c.

5017{
5018 /* must match what we defive from decapsulated key */
5020 GNUNET_CRYPTO_hkdf_expand (&key->material,
5021 sizeof(key->material),
5022 km,
5023 "gnunet-transport-dv-key",
5024 strlen ("gnunet-transport-dv-key")
5025 ,
5026 km,
5027 sizeof(*km),
5028 iv,
5029 sizeof(*iv),
5030 NULL));
5032 "Deriving backchannel key based on KM %s and IV %s\n",
5033 GNUNET_sh2s (km),
5034 GNUNET_sh2s (iv));
5035 GNUNET_assert (0 == gcry_cipher_open (&key->cipher,
5036 GCRY_CIPHER_AES256 /* low level: go for speed */
5037 ,
5038 GCRY_CIPHER_MODE_CTR,
5039 0 /* flags */));
5040 GNUNET_assert (0 == gcry_cipher_setkey (key->cipher,
5041 &key->material.aes_key,
5042 sizeof(key->material.aes_key)));
5043 gcry_cipher_setctr (key->cipher,
5044 &key->material.aes_ctr,
5045 sizeof(key->material.aes_ctr));
5046}
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_hkdf_expand(void *result, size_t out_len, const struct GNUNET_ShortHashCode *prk,...)
HKDF-Expand using SHA256.
Definition: crypto_hkdf.c:156
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).

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

Referenced by encapsulate_for_dv(), and handle_dv_box().

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

◆ dv_hmac()

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

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

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

Definition at line 5059 of file gnunet-service-transport.c.

5063{
5064 GNUNET_CRYPTO_hmac (&key->material.hmac_key, data, data_size, hmac);
5065}
static char * data
The data to insert into the dht.
static size_t data_size
Number of bytes in data.
void GNUNET_CRYPTO_hmac(const struct GNUNET_CRYPTO_AuthKey *key, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104)
Definition: crypto_hash.c:327

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

Referenced by encapsulate_for_dv(), and handle_dv_box().

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

◆ dv_encrypt()

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

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

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

Definition at line 5078 of file gnunet-service-transport.c.

5079{
5080 GNUNET_assert (0 ==
5081 gcry_cipher_encrypt (key->cipher, dst, in_size, in, in_size));
5082}

References GNUNET_assert, and key.

Referenced by encapsulate_for_dv().

Here is the caller graph for this function:

◆ dv_decrypt()

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

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

Parameters
[in,out]keykey material to use
ciphcipher text to decrypt
[out]outoutput data to generate (plaintext)
out_sizenumber of bytes of input in ciph and available in out
Returns
GNUNET_OK on success

Definition at line 5096 of file gnunet-service-transport.c.

5100{
5101 return (0 ==
5102 gcry_cipher_decrypt (key->cipher,
5103 out, out_size,
5104 ciph, out_size)) ? GNUNET_OK : GNUNET_SYSERR;
5105}

References GNUNET_OK, GNUNET_SYSERR, and key.

Referenced by handle_dv_box().

Here is the caller graph for this function:

◆ dv_key_clean()

static void dv_key_clean ( struct DVKeyState key)
static

Clean up key material in key.

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

Definition at line 5114 of file gnunet-service-transport.c.

5115{
5116 gcry_cipher_close (key->cipher);
5117 GNUNET_CRYPTO_zero_keys (&key->material, sizeof(key->material));
5118}
void GNUNET_CRYPTO_zero_keys(void *buffer, size_t length)
Zero out buffer, securely against compiler optimizations.

References GNUNET_CRYPTO_zero_keys(), and key.

Referenced by encapsulate_for_dv(), and handle_dv_box().

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

◆ encapsulate_for_dv()

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

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

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

Definition at line 5151 of file gnunet-service-transport.c.

5159{
5160 struct TransportDVBoxMessage box_hdr;
5161 struct TransportDVBoxPayloadP payload_hdr;
5162 uint16_t enc_body_size = ntohs (hdr->size);
5163 char enc[sizeof(struct TransportDVBoxPayloadP) + enc_body_size] GNUNET_ALIGN;
5164 struct DVKeyState *key;
5165 struct GNUNET_TIME_Relative rtt;
5166 struct GNUNET_ShortHashCode km;
5167
5168 key = GNUNET_new (struct DVKeyState);
5169 /* Encrypt payload */
5170 box_hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
5171 box_hdr.total_hops = htons (0);
5172 box_hdr.without_fc = htons (without_fc);
5173 // update_ephemeral (dv);
5174 if (0 ==
5176 {
5178 &dv->ephemeral_key,
5179 &km);
5180 dv->km = GNUNET_new (struct GNUNET_ShortHashCode);
5181 GNUNET_memcpy (dv->km, &km, sizeof(struct GNUNET_ShortHashCode));
5182 sign_ephemeral (dv);
5183 }
5184 box_hdr.ephemeral_key = dv->ephemeral_key;
5185 payload_hdr.sender_sig = dv->sender_sig;
5186
5188 &box_hdr.iv,
5189 sizeof(box_hdr.iv));
5190 // We are creating this key, so this must work.
5191 // FIXME: Possibly also add return values here. We are processing
5192 // Input from other peers...
5193 dv_setup_key_state_from_km (dv->km, &box_hdr.iv, key);
5194 payload_hdr.sender = GST_my_identity;
5195 payload_hdr.monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
5196 dv_encrypt (key, &payload_hdr, enc, sizeof(payload_hdr));
5197 dv_encrypt (key,
5198 hdr,
5199 &enc[sizeof(struct TransportDVBoxPayloadP)],
5200 enc_body_size);
5201 dv_hmac (key, &box_hdr.hmac, enc, sizeof(enc));
5202 dv_key_clean (key);
5204 /* For each selected path, take the pre-computed header and body
5205 and add the path in the middle of the message; then send it. */
5206 for (unsigned int i = 0; i < num_dvhs; i++)
5207 {
5208 struct DistanceVectorHop *dvh = dvhs[i];
5209 unsigned int num_hops = dvh->distance + 1;
5210 char buf[sizeof(struct TransportDVBoxMessage)
5211 + sizeof(struct GNUNET_PeerIdentity) * num_hops
5212 + sizeof(struct TransportDVBoxPayloadP)
5213 + enc_body_size] GNUNET_ALIGN;
5214 struct GNUNET_PeerIdentity *dhops;
5215
5216 box_hdr.header.size = htons (sizeof(buf));
5217 box_hdr.orig_size = htons (sizeof(buf));
5218 box_hdr.num_hops = htons (num_hops);
5219 memcpy (buf, &box_hdr, sizeof(box_hdr));
5220 dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)];
5221 memcpy (dhops,
5222 dvh->path,
5223 dvh->distance * sizeof(struct GNUNET_PeerIdentity));
5224 dhops[dvh->distance] = dv->target;
5225 if (GNUNET_EXTRA_LOGGING > 0)
5226 {
5227 char *path;
5228
5230 for (unsigned int j = 0; j < num_hops; j++)
5231 {
5232 char *tmp;
5233
5234 GNUNET_asprintf (&tmp, "%s-%s", path, GNUNET_i2s (&dhops[j]));
5235 GNUNET_free (path);
5236 path = tmp;
5237 }
5239 "Routing message of type %u to %s using DV (#%u/%u) via %s\n",
5240 ntohs (hdr->type),
5241 GNUNET_i2s (&dv->target),
5242 i + 1,
5243 num_dvhs,
5244 path);
5245 GNUNET_free (path);
5246 }
5247 rtt = GNUNET_TIME_relative_min (rtt, dvh->pd.aged_rtt);
5248 memcpy (&dhops[num_hops], enc, sizeof(enc));
5249 use (use_cls,
5250 dvh->next_hop,
5251 (const struct GNUNET_MessageHeader *) buf,
5252 options);
5253 GNUNET_free (key);
5254 }
5255 return rtt;
5256}
static OpusEncoder * enc
OPUS encoder.
static void dv_key_clean(struct DVKeyState *key)
Clean up key material in key.
static void sign_ephemeral(struct DistanceVector *dv)
Sign ephemeral keys in our dv are current.
static void dv_hmac(const struct DVKeyState *key, struct GNUNET_HashCode *hmac, const void *data, size_t data_size)
Do HMAC calculation for backchannel messages over data using key material from key.
static void dv_setup_key_state_from_km(const struct GNUNET_ShortHashCode *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...
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.
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_kem_encaps(const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct GNUNET_ShortHashCode *prk)
Encapsulate key material for a EdDSA public key.
Definition: crypto_hpke.c:312
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_EXTRA_LOGGING
define GNUNET_EXTRA_LOGGING if using this header outside the GNUnet source tree where gnunet_config....
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX
Source-routed transport message based DV information gathered.
Structure of the key material used to encrypt backchannel messages.
struct PerformanceData pd
Performance data for this transmission possibility.
unsigned int distance
Number of hops in total to the target (excluding next_hop and target itself).
const struct GNUNET_PeerIdentity * path
Array of distance hops to the target, excluding next_hop.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
A 256-bit hashcode.
struct GNUNET_TIME_Relative aged_rtt
Weighted average for the RTT.
uint16_t num_hops
Number of hops this messages includes.

References PerformanceData::aged_rtt, DistanceVectorHop::distance, dv_encrypt(), dv_hmac(), dv_key_clean(), dv_setup_key_state_from_km(), enc, TransportDVBoxMessage::ephemeral_key, GNUNET_ALIGN, GNUNET_asprintf(), GNUNET_CRYPTO_eddsa_kem_encaps(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_block(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_EXTRA_LOGGING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX, GNUNET_new, GNUNET_strdup, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_min(), GNUNET_TIME_UNIT_FOREVER_REL, GST_my_identity, TransportDVBoxMessage::header, TransportDVBoxMessage::hmac, TransportDVBoxMessage::iv, key, TransportDVBoxPayloadP::monotonic_time, DistanceVectorHop::next_hop, TransportDVBoxMessage::num_hops, options, TransportDVBoxMessage::orig_size, DistanceVectorHop::path, DistanceVectorHop::pd, GNUNET_TIME_Relative::rel_value_us, TransportDVBoxPayloadP::sender, TransportDVBoxPayloadP::sender_sig, sign_ephemeral(), GNUNET_MessageHeader::size, TransportDVBoxMessage::total_hops, GNUNET_MessageHeader::type, and TransportDVBoxMessage::without_fc.

Referenced by route_control_message_without_fc(), and transmit_on_queue().

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

◆ send_dv_to_neighbour()

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

Wrapper around route_via_neighbour() that matches the DVMessageHandler structure.

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

Definition at line 5269 of file gnunet-service-transport.c.

5273{
5274 (void) cls;
5275 (void) route_via_neighbour (next_hop, hdr, RMO_UNCONFIRMED_ALLOWED);
5276}
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.

References RMO_UNCONFIRMED_ALLOWED, and route_via_neighbour().

Referenced by route_control_message_without_fc().

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

◆ route_control_message_without_fc()

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

We need to transmit hdr to target.

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

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

Definition at line 5291 of file gnunet-service-transport.c.

5295{
5296 // struct VirtualLink *vl;
5297 struct Neighbour *n;
5298 struct DistanceVector *dv;
5299 struct GNUNET_TIME_Relative rtt1;
5300 struct GNUNET_TIME_Relative rtt2;
5301 const struct GNUNET_PeerIdentity *target = &vl->target;
5302
5304 "Trying to route message of type %u to %s without fc\n",
5305 ntohs (hdr->type),
5306 GNUNET_i2s (target));
5307
5308 // TODO Do this elsewhere. vl should be given as parameter to method.
5309 // vl = lookup_virtual_link (target);
5310 GNUNET_assert (NULL != vl && GNUNET_YES == vl->confirmed);
5311 if (NULL == vl)
5313 n = vl->n;
5314 dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL;
5315 if (0 == (options & RMO_UNCONFIRMED_ALLOWED))
5316 {
5317 /* if confirmed is required, and we do not have anything
5318 confirmed, drop respective options */
5319 if (NULL == n)
5320 n = lookup_neighbour (target);
5321 if ((NULL == dv) && (0 != (options & RMO_DV_ALLOWED)))
5323 }
5324 if ((NULL == n) && (NULL == dv))
5325 {
5327 "Cannot route message of type %u to %s: no route\n",
5328 ntohs (hdr->type),
5329 GNUNET_i2s (target));
5331 "# Messages dropped in routing: no acceptable method",
5332 1,
5333 GNUNET_NO);
5335 }
5337 "Routing message of type %u to %s with options %X\n",
5338 ntohs (hdr->type),
5339 GNUNET_i2s (target),
5340 (unsigned int) options);
5341 /* If both dv and n are possible and we must choose:
5342 flip a coin for the choice between the two; for now 50/50 */
5343 if ((NULL != n) && (NULL != dv) && (0 == (options & RMO_REDUNDANT)))
5344 {
5346 n = NULL;
5347 else
5348 dv = NULL;
5349 }
5350 if ((NULL != n) && (NULL != dv))
5351 options &= ~RMO_REDUNDANT; /* We will do one DV and one direct, that's
5352 enough for redundancy, so clear the flag. */
5355 if (NULL != n)
5356 {
5358 "Try to route message of type %u to %s without fc via neighbour\n",
5359 ntohs (hdr->type),
5360 GNUNET_i2s (target));
5361 rtt1 = route_via_neighbour (n, hdr, options);
5362 }
5363 if (NULL != dv)
5364 {
5365 struct DistanceVectorHop *hops[2];
5366 unsigned int res;
5367
5369 options,
5370 hops,
5371 (0 == (options & RMO_REDUNDANT)) ? 1 : 2);
5372 if (0 == res)
5373 {
5375 "Failed to route message, could not determine DV path\n");
5376 return rtt1;
5377 }
5379 "encapsulate_for_dv 1\n");
5380 rtt2 = encapsulate_for_dv (dv,
5381 res,
5382 hops,
5383 hdr,
5385 NULL,
5387 GNUNET_YES);
5388 }
5389 return GNUNET_TIME_relative_min (rtt1, rtt2);
5390}
static char * res
Currently read line or NULL on EOF.
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.
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.
static struct Neighbour * lookup_neighbour(const struct GNUNET_PeerIdentity *pid)
Lookup neighbour for peer pid.

References DistanceVectorHop::dv, dv_routes, encapsulate_for_dv(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), 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_relative_min(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GST_stats, lookup_neighbour(), options, pick_random_dv_hops(), res, RMO_DV_ALLOWED, RMO_REDUNDANT, RMO_UNCONFIRMED_ALLOWED, route_via_neighbour(), send_dv_to_neighbour(), and GNUNET_MessageHeader::type.

Referenced by consider_sending_fc(), forward_dv_learn(), handle_communicator_backchannel(), handle_validation_challenge(), and transmit_cummulative_ack_cb().

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

◆ consider_sending_fc()

static void consider_sending_fc ( void *  cls)
static

Something changed on the virtual link with respect to flow control.

Consider retransmitting the FC window size.

Parameters
clsa struct VirtualLink to work with

Definition at line 5456 of file gnunet-service-transport.c.

5457{
5458 struct VirtualLink *vl = cls;
5459 struct GNUNET_TIME_Absolute monotime;
5460 struct TransportFlowControlMessage *fc;
5462 struct GNUNET_TIME_Relative rtt;
5463 struct GNUNET_TIME_Relative rtt_average;
5464 struct Neighbour *n = vl->n;
5465
5466 if (NULL != n && 0 < n->number_of_addresses)
5467 {
5468 size_t addresses_size =
5469 n->number_of_addresses * sizeof (struct TransportGlobalNattedAddress) + n
5470 ->size_of_global_addresses;
5471 char *tgnas = GNUNET_malloc (addresses_size);
5473 ctx.off = 0;
5474 ctx.tgnas = tgnas;
5475
5476 fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage)
5477 + addresses_size);
5478 fc->header.size = htons (sizeof(struct TransportFlowControlMessage)
5479 + addresses_size);
5484 &ctx);
5485 GNUNET_memcpy (&fc[1], tgnas, addresses_size);
5487 }
5488 else
5489 {
5490 fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage));
5491 fc->header.size = htons (sizeof(struct TransportFlowControlMessage));
5492 }
5493
5495 /* OPTIMIZE-FC-BDP: decide sane criteria on when to do this, instead of doing
5496 it always! */
5497 /* For example, we should probably ONLY do this if a bit more than
5498 an RTT has passed, or if the window changed "significantly" since
5499 then. See vl->last_fc_rtt! NOTE: to do this properly, we also
5500 need an estimate for the bandwidth-delay-product for the entire
5501 VL, as that determines "significantly". We have the delay, but
5502 the bandwidth statistics need to be added for the VL!*/(void) duration;
5503
5504 if (NULL != vl->dv)
5505 rtt_average = calculate_rtt (vl->dv);
5506 else
5507 rtt_average = GNUNET_TIME_UNIT_FOREVER_REL;
5508 fc->rtt = GNUNET_TIME_relative_hton (rtt_average);
5510 "Sending FC seq %u to %s with new window %llu %lu %u\n",
5511 (unsigned int) vl->fc_seq_gen,
5512 GNUNET_i2s (&vl->target),
5513 (unsigned long long) vl->incoming_fc_window_size,
5514 (unsigned long) rtt_average.rel_value_us,
5515 vl->sync_ready);
5517 vl->last_fc_transmission = monotime;
5518 fc->sync_ready = vl->sync_ready;
5520 fc->seq = htonl (vl->fc_seq_gen++);
5526 fc->sender_time = GNUNET_TIME_absolute_hton (monotime);
5528 if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us)
5529 {
5532 "FC retransmission to %s failed, will retry in %s\n",
5533 GNUNET_i2s (&vl->target),
5536 }
5537 else
5538 {
5539 /* OPTIMIZE-FC-BDP: rtt is not ideal, we can do better! */
5540 vl->last_fc_rtt = rtt;
5541 }
5542 if (NULL != vl->fc_retransmit_task)
5545 {
5547 vl->fc_retransmit_count = 0;
5548 }
5549 vl->fc_retransmit_task =
5551 vl->fc_retransmit_count++;
5552 GNUNET_free (fc);
5553}
static struct GNUNET_FS_Handle * ctx
#define MAX_FC_RETRANSMIT_COUNT
Maximum number of FC retransmissions for a running retransmission task.
static void task_consider_sending_fc(void *cls)
Something changed on the virtual link with respect to flow control.
static struct GNUNET_TIME_Relative calculate_rtt(struct DistanceVector *dv)
static enum GNUNET_GenericReturnValue add_global_addresses(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
static struct GNUNET_TIME_Relative route_control_message_without_fc(struct VirtualLink *vl, const struct GNUNET_MessageHeader *hdr, enum RouteMessageOptions options)
We need to transmit hdr to target.
static struct GNUNET_TIME_Relative duration
Option '-d': duration of the mapping.
Definition: gnunet-vpn.c:90
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL
Transport signalling incoming backchannel message to a communicator.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:438
size_t size_of_global_addresses
Size of all global natted addresses for this neighbour.
unsigned int number_of_addresses
Number of global natted addresses for this neighbour.
Message for Transport-to-Transport Flow control.
uint64_t outbound_window_size
Latest flow control window size we learned from the other peer, in bytes, in NBO.
unsigned int number_of_addresses
Number of TransportGlobalNattedAddress following the struct.
size_t size_of_addresses
Size of all the addresses attached to all TransportGlobalNattedAddress.
uint64_t inbound_window_size
Flow control window size in bytes, in NBO.
struct GNUNET_TIME_AbsoluteNBO sender_time
Timestamp of the sender.
uint32_t seq
Sequence number of the flow control message.
uint64_t outbound_sent
How many bytes has the sender sent that count for flow control at this time.
struct GNUNET_TIME_RelativeNBO rtt
Average RTT for the DistanceVector of the VirtualLink we tell the target.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL.
unsigned int sync_ready
We tell the target, if we are ready to start the burst.

References add_global_addresses(), calculate_rtt(), ctx, duration, VirtualLink::dv, VirtualLink::fc_retransmit_count, VirtualLink::fc_retransmit_task, VirtualLink::fc_seq_gen, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_htonll(), GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_hton(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_MINUTES, GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GST_cfg, TransportFlowControlMessage::header, TransportFlowControlMessage::inbound_window_size, VirtualLink::incoming_fc_window_size, VirtualLink::incoming_fc_window_size_loss, VirtualLink::incoming_fc_window_size_used, VirtualLink::last_fc_rtt, VirtualLink::last_fc_transmission, MAX_FC_RETRANSMIT_COUNT, VirtualLink::n, TransportFlowControlMessage::number_of_addresses, Neighbour::number_of_addresses, VirtualLink::outbound_fc_window_size, VirtualLink::outbound_fc_window_size_used, TransportFlowControlMessage::outbound_sent, TransportFlowControlMessage::outbound_window_size, GNUNET_TIME_Relative::rel_value_us, RMO_DV_ALLOWED, route_control_message_without_fc(), TransportFlowControlMessage::rtt, TransportFlowControlMessage::sender_time, TransportFlowControlMessage::seq, GNUNET_MessageHeader::size, TransportFlowControlMessage::size_of_addresses, TransportFlowControlMessage::sync_ready, VirtualLink::sync_ready, VirtualLink::target, task_consider_sending_fc(), AddGlobalAddressesContext::tgnas, GNUNET_MessageHeader::type, and Neighbour::vl.

Referenced by activate_core_visible_dv_path(), check_vl_transmission(), core_env_sent_cb(), handle_flow_control(), handle_validation_response(), and task_consider_sending_fc().

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

◆ task_consider_sending_fc()

static void task_consider_sending_fc ( void *  cls)
static

Something changed on the virtual link with respect to flow control.

Consider retransmitting the FC window size.

Parameters
clsa struct VirtualLink to work with

Definition at line 5403 of file gnunet-service-transport.c.

5404{
5405 struct VirtualLink *vl = cls;
5406 vl->fc_retransmit_task = NULL;
5407 consider_sending_fc (cls);
5408}
static void consider_sending_fc(void *cls)
Something changed on the virtual link with respect to flow control.

References consider_sending_fc(), and VirtualLink::fc_retransmit_task.

Referenced by consider_sending_fc().

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

◆ get_address_without_port()

static char * get_address_without_port ( const char *  address)
static

Get the IP address without the port number.

Parameters
addressThe string contains a communicator prefix, IP address and port like this 'tcp-92.68.150.1:55452'.
Returns
String with IP address only.

Definition at line 11898 of file gnunet-service-transport.c.

11899{
11900 const char *colon;
11901 char *colon_rest;
11902 size_t colon_rest_length;
11903 char *address_without_port;
11904
11905 colon = strchr (address,':');
11906 colon_rest = GNUNET_strndup (address, colon - address);
11907 colon_rest_length = strlen (colon_rest);
11908 address_without_port = GNUNET_strndup (&colon_rest[4], colon_rest_length - 4);
11909 GNUNET_free (colon_rest);
11910
11911 return address_without_port;
11912}
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.

References address, GNUNET_free, and GNUNET_strndup.

Referenced by check_for_global_natted(), check_validation_request_pending(), create_address_entry(), handle_add_queue_message(), iterate_address_and_compare_cb(), and iterate_address_start_burst().

Here is the caller graph for this function:

◆ add_global_addresses()

static enum GNUNET_GenericReturnValue add_global_addresses ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Definition at line 5423 of file gnunet-service-transport.c.

5426{
5427 struct AddGlobalAddressesContext *ctx = cls;
5428 struct TransportGlobalNattedAddress *tgna = value;
5429 char *addr = (char *) &tgna[1];
5430
5432 "sending address %s length %u\n",
5433 addr,
5434 ntohl (tgna->address_length));
5435 GNUNET_memcpy (&(ctx->tgnas[ctx->off]), tgna, sizeof (struct
5437 + ntohl (tgna->address_length));
5438 ctx->off += sizeof(struct TransportGlobalNattedAddress) + ntohl (tgna->
5440
5441 return GNUNET_OK;
5442}
unsigned int address_length
Length of the address following the struct in NBO.

References TransportGlobalNattedAddress::address_length, ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_OK, and value.

Referenced by consider_sending_fc().

Here is the caller graph for this function:

◆ calculate_rtt()

static struct GNUNET_TIME_Relative calculate_rtt ( struct DistanceVector dv)
static

Definition at line 9781 of file gnunet-service-transport.c.

9782{
9784 unsigned int n_hops = 0;
9785
9787 "calculate_rtt\n");
9788 for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
9789 pos = pos->next_dv)
9790 {
9792 "calculate_rtt %lu\n",
9793 (unsigned long) pos->pd.aged_rtt.rel_value_us);
9794 n_hops++;
9796 aged_rtt, pos
9797 ->distance
9798 + 2), ret);
9799 }
9800
9801 GNUNET_assert (0 != n_hops);
9802
9803 return ret;
9804}
static int ret
Final status code.
Definition: gnunet-arm.c:93
struct GNUNET_TIME_Relative GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Add relative times together.
Definition: time.c:587

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_TIME_relative_add(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_ZERO, and ret.

Referenced by consider_sending_fc(), and handle_flow_control().

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

◆ check_vl_transmission()

static void check_vl_transmission ( struct VirtualLink vl)
static

There is a message at the head of the pending messages for vl which may be ready for transmission.

Check if a queue is ready to take it.

This function must (1) check for flow control to ensure that we can right now send to vl, (2) check that the pending message in the queue is actually eligible, (3) determine if any applicable queue (direct neighbour or DVH path) is ready to accept messages, and (4) prioritize based on the preferences associated with the pending message.

So yeah, easy.

Parameters
vlvirtual link where we should check for transmission

Definition at line 5573 of file gnunet-service-transport.c.

5574{
5575 struct Neighbour *n = vl->n;
5576 struct DistanceVector *dv = vl->dv;
5577 struct GNUNET_TIME_Absolute now;
5578 struct VirtualLink *vl_next_hop;
5579 int elig;
5580
5582 "check_vl_transmission to target %s\n",
5583 GNUNET_i2s (&vl->target));
5584 /* Check that we have an eligible pending message!
5585 (cheaper than having #transmit_on_queue() find out!) */
5586 elig = GNUNET_NO;
5587 for (struct PendingMessage *pm = vl->pending_msg_head; NULL != pm;
5588 pm = pm->next_vl)
5589 {
5591 "check_vl_transmission loop\n");
5592 if (NULL != pm->qe)
5593 continue; /* not eligible, is in a queue! */
5594 if (pm->bytes_msg + vl->outbound_fc_window_size_used >
5596 {
5598 "Stalled message %" PRIu64
5599 " transmission on VL %s due to flow control: %llu < %llu\n",
5600 pm->logging_uuid,
5601 GNUNET_i2s (&vl->target),
5602 (unsigned long long) vl->outbound_fc_window_size,
5603 (unsigned long long) (pm->bytes_msg
5606 return; /* We have a message, but flow control says "nope" */
5607 }
5609 "Target window on VL %s not stalled. Scheduling transmission on queue\n",
5610 GNUNET_i2s (&vl->target));
5611 /* Notify queues at direct neighbours that we are interested */
5612 now = GNUNET_TIME_absolute_get ();
5613 if (NULL != n)
5614 {
5615 for (struct Queue *queue = n->queue_head; NULL != queue;
5616 queue = queue->next_neighbour)
5617 {
5618 if ((GNUNET_YES == queue->idle) &&
5619 (queue->validated_until.abs_value_us > now.abs_value_us))
5620 {
5622 "Direct neighbour %s not stalled\n",
5623 GNUNET_i2s (&n->pid));
5625 queue,
5627 elig = GNUNET_YES;
5628 }
5629 else
5631 "Neighbour Queue QID: %u (%u) busy or invalid\n",
5632 queue->qid,
5633 queue->idle);
5634 }
5635 }
5636 /* Notify queues via DV that we are interested */
5637 if (NULL != dv)
5638 {
5639 /* Do DV with lower scheduler priority, which effectively means that
5640 IF a neighbour exists and is available, we prefer it. */
5641 for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
5642 pos = pos->next_dv)
5643 {
5644 struct Neighbour *nh_iter = pos->next_hop;
5645
5646
5647 if (pos->path_valid_until.abs_value_us <= now.abs_value_us)
5648 continue; /* skip this one: path not validated */
5649 else
5650 {
5651 vl_next_hop = lookup_virtual_link (&nh_iter->pid);
5652 GNUNET_assert (NULL != vl_next_hop);
5653 if (pm->bytes_msg + vl_next_hop->outbound_fc_window_size_used >
5654 vl_next_hop->outbound_fc_window_size)
5655 {
5657 "Stalled message %" PRIu64
5658 " transmission on next hop %s due to flow control: %llu < %llu\n",
5659 pm->logging_uuid,
5660 GNUNET_i2s (&vl_next_hop->target),
5661 (unsigned long
5662 long) vl_next_hop->outbound_fc_window_size,
5663 (unsigned long long) (pm->bytes_msg
5664 + vl_next_hop->
5665 outbound_fc_window_size_used));
5666 consider_sending_fc (vl_next_hop);
5667 continue; /* We have a message, but flow control says "nope" for the first hop of this path */
5668 }
5669 for (struct Queue *queue = nh_iter->queue_head; NULL != queue;
5670 queue = queue->next_neighbour)
5671 if ((GNUNET_YES == queue->idle) &&
5672 (queue->validated_until.abs_value_us > now.abs_value_us))
5673 {
5675 "Next hop neighbour %s not stalled\n",
5676 GNUNET_i2s (&nh_iter->pid));
5678 queue,
5680 elig = GNUNET_YES;
5681 }
5682 else
5684 "DV Queue QID: %u (%u) busy or invalid\n",
5685 queue->qid,
5686 queue->idle);
5687 }
5688 }
5689 }
5690 if (GNUNET_YES == elig)
5692 "Eligible message %" PRIu64 " of size %u to %s: %llu/%llu\n",
5693 pm->logging_uuid,
5694 pm->bytes_msg,
5695 GNUNET_i2s (&vl->target),
5696 (unsigned long long) vl->outbound_fc_window_size,
5697 (unsigned long long) (pm->bytes_msg
5699 break;
5700 }
5701}
@ GNUNET_SCHEDULER_PRIORITY_BACKGROUND
Run as background job (higher than idle, lower than default).

References GNUNET_TIME_Absolute::abs_value_us, consider_sending_fc(), VirtualLink::dv, DistanceVector::dv_head, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_PRIORITY_BACKGROUND, GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_ZERO, GNUNET_YES, lookup_virtual_link(), VirtualLink::n, DistanceVectorHop::next_dv, VirtualLink::outbound_fc_window_size, VirtualLink::outbound_fc_window_size_used, VirtualLink::pending_msg_head, Neighbour::pid, pm, queue(), Neighbour::queue_head, schedule_transmit_on_queue(), VirtualLink::target, DistanceVector::vl, and Neighbour::vl.

Referenced by forward_dv_box(), free_queue_entry(), handle_client_send(), handle_flow_control(), and send_msg_from_cache().

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

◆ handle_client_send()

static void handle_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 5711 of file gnunet-service-transport.c.

5712{
5713 struct TransportClient *tc = cls;
5714 struct PendingMessage *pm;
5715 const struct GNUNET_MessageHeader *obmm;
5716 uint32_t bytes_msg;
5717 struct VirtualLink *vl;
5719
5720 GNUNET_assert (CT_CORE == tc->type);
5721 obmm = (const struct GNUNET_MessageHeader *) &obm[1];
5722 bytes_msg = ntohs (obmm->size);
5723 pp = ntohl (obm->priority);
5724 vl = lookup_virtual_link (&obm->peer);
5725 if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
5726 {
5728 "Don't have %s as a neighbour (anymore).\n",
5729 GNUNET_i2s (&obm->peer));
5730 /* Failure: don't have this peer as a neighbour (anymore).
5731 Might have gone down asynchronously, so this is NOT
5732 a protocol violation by CORE. Still count the event,
5733 as this should be rare. */
5736 "# messages dropped (neighbour unknown)",
5737 1,
5738 GNUNET_NO);
5739 return;
5740 }
5741
5742 pm = GNUNET_malloc (sizeof(struct PendingMessage) + bytes_msg);
5744 "1 created pm %p storing vl %p\n",
5745 pm,
5746 vl);
5747 pm->logging_uuid = logging_uuid_gen++;
5748 pm->prefs = pp;
5749 pm->client = tc;
5750 pm->vl = vl;
5751 pm->bytes_msg = bytes_msg;
5752 memcpy (&pm[1], obmm, bytes_msg);
5754 "Sending message of type %u with %u bytes as <%" PRIu64
5755 "> to %s\n",
5756 ntohs (obmm->type),
5757 bytes_msg,
5758 pm->logging_uuid,
5759 GNUNET_i2s (&obm->peer));
5761 tc->details.core.pending_msg_head,
5762 tc->details.core.pending_msg_tail,
5763 pm);
5765 vl->pending_msg_head,
5766 vl->pending_msg_tail,
5767 pm);
5770}
static unsigned long long logging_uuid_gen
Generator of logging_uuid in struct PendingMessage.
#define GNUNET_CONTAINER_MDLL_insert(mdll, head, tail, element)
Insert an element at the head of a MDLL.
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
uint32_t priority
An enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: transport.h:238
struct GNUNET_PeerIdentity peer
Which peer should receive the message?
Definition: transport.h:252

References check_vl_transmission(), VirtualLink::confirmed, CT_CORE, GNUNET_assert, GNUNET_CONTAINER_MDLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GST_stats, logging_uuid_gen, lookup_virtual_link(), OutboundMessage::peer, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, pm, OutboundMessage::priority, GNUNET_MessageHeader::size, tc, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ handle_communicator_backchannel()

static void handle_communicator_backchannel ( void *  cls,
const struct GNUNET_TRANSPORT_CommunicatorBackchannel cb 
)
static

Communicator requests backchannel transmission.

Process the request. Just repacks it into our struct TransportBackchannelEncapsulationMessage * (which for now has exactly the same format, only a different message type) and passes it on for routing.

Parameters
clsthe client
cbthe send message that was sent

Definition at line 5783 of file gnunet-service-transport.c.

5786{
5787 struct Neighbour *n;
5788 struct VirtualLink *vl;
5789 struct TransportClient *tc = cls;
5790 const struct GNUNET_MessageHeader *inbox =
5791 (const struct GNUNET_MessageHeader *) &cb[1];
5792 uint16_t isize = ntohs (inbox->size);
5793 const char *is = ((const char *) &cb[1]) + isize;
5794 size_t slen = strlen (is) + 1;
5795 char
5796 mbuf[slen + isize
5797 + sizeof(struct
5801
5802 /* 0-termination of 'is' was checked already in
5803 #check_communicator_backchannel() */
5805 "Preparing backchannel transmission to %s:%s of type %u and size %u\n",
5806 GNUNET_i2s (&cb->pid),
5807 is,
5808 ntohs (inbox->type),
5809 ntohs (inbox->size));
5810 /* encapsulate and encrypt message */
5811 be->header.type =
5813 be->header.size = htons (sizeof(mbuf));
5814 memcpy (&be[1], inbox, isize);
5815 memcpy (&mbuf[sizeof(struct TransportBackchannelEncapsulationMessage)
5816 + isize],
5817 is,
5818 strlen (is) + 1);
5819 // route_control_message_without_fc (&cb->pid, &be->header, RMO_DV_ALLOWED);
5820 vl = lookup_virtual_link (&cb->pid);
5821 if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
5822 {
5824 }
5825 else
5826 {
5827 /* Use route via neighbour */
5828 n = lookup_neighbour (&cb->pid);
5829 if (NULL != n)
5831 n,
5832 &be->header,
5833 RMO_NONE);
5834 }
5836}
#define GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION
Message type used between transport services when they internally forward communicator backchannel me...
struct GNUNET_PeerIdentity pid
Target peer.
Definition: transport.h:640
Outer layer of an encapsulated backchannel message.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION.

References VirtualLink::confirmed, GNUNET_ALIGN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION, GNUNET_SERVICE_client_continue(), GNUNET_YES, TransportBackchannelEncapsulationMessage::header, is, lookup_neighbour(), lookup_virtual_link(), GNUNET_TRANSPORT_CommunicatorBackchannel::pid, RMO_DV_ALLOWED, RMO_NONE, route_control_message_without_fc(), route_via_neighbour(), GNUNET_MessageHeader::size, tc, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ check_add_address()

static int check_add_address ( void *  cls,
const struct GNUNET_TRANSPORT_AddAddressMessage aam 
)
static

Address of our peer added.

Test message is well-formed.

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

Definition at line 5847 of file gnunet-service-transport.c.

5849{
5850 struct TransportClient *tc = cls;
5851
5852 if (CT_COMMUNICATOR != tc->type)
5853 {
5854 GNUNET_break (0);
5855 return GNUNET_SYSERR;
5856 }
5858 return GNUNET_OK;
5859}

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

◆ store_pi()

static void store_pi ( void *  cls)
static

Ask peerstore to store our address.

Parameters
clsan struct AddressListEntry *

Definition at line 5936 of file gnunet-service-transport.c.

5937{
5938 struct AddressListEntry *ale = cls;
5939 struct GNUNET_MQ_Envelope *env;
5940 const struct GNUNET_MessageHeader *msg;
5941 const char *dash;
5942 char *address_uri;
5944 unsigned int add_success;
5945
5946 dash = strchr (ale->address, '-');
5947 GNUNET_assert (NULL != dash);
5948 dash++;
5949 GNUNET_asprintf (&address_uri,
5950 "%s://%s",
5951 prefix,
5952 dash);
5954 ale->st = NULL;
5956 "Storing our address `%s' in peerstore until %s!\n",
5957 ale->address,
5960 address_uri);
5961 if (GNUNET_OK != add_success)
5962 {
5964 "Storing our address `%s' %s\n",
5965 address_uri,
5966 GNUNET_NO == add_success ? "not done" : "failed");
5967 GNUNET_free (address_uri);
5968 return;
5969 }
5970 else
5971 {
5972
5974 "Storing our address `%s'\n",
5975 address_uri);
5976 }
5977 // FIXME hello_mono_time used here?? What about expiration in ale?
5979 ale->nt,
5982 &ale->signed_address,
5983 &ale->signed_address_len);
5984 GNUNET_free (address_uri);
5990 "store_pi 1\n");
5992 msg,
5993 shc_cont,
5994 ale);
5995 GNUNET_free (env);
5996}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int prefix
If printing the value of PREFIX has been requested.
Definition: gnunet-config.c:65
static void shc_cont(void *cls, int success)
static struct GNUNET_TIME_Absolute hello_mono_time
Monotonic time we use for HELLOs generated at this time.
void GNUNET_HELLO_sign_address(const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Absolute mono_time, const struct GNUNET_CRYPTO_EddsaPrivateKey *private_key, void **result, size_t *result_size)
Build address record by signing raw information with private key.
Definition: hello-uri.c:1310
enum GNUNET_GenericReturnValue GNUNET_HELLO_builder_add_address(struct GNUNET_HELLO_Builder *builder, const char *address)
Add individual address to the builder.
Definition: hello-uri.c:646
char * GNUNET_HELLO_address_to_prefix(const char *address)
Given an address as a string, extract the prefix that identifies the communicator offering transmissi...
Definition: hello-uri.c:1288
struct GNUNET_MQ_Envelope * GNUNET_HELLO_builder_to_env(const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_TIME_Relative expiration_time)
Generate envelope with GNUnet HELLO message (including peer ID) from a builder.
Definition: hello-uri.c:1168
@ GNUNET_ERROR_TYPE_WARNING
const struct GNUNET_MessageHeader * GNUNET_MQ_env_get_msg(const struct GNUNET_MQ_Envelope *env)
Obtain message contained in envelope.
Definition: mq.c:896
struct GNUNET_PEERSTORE_StoreHelloContext * GNUNET_PEERSTORE_hello_add(struct GNUNET_PEERSTORE_Handle *h, const struct GNUNET_MessageHeader *msg, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
Add hello to peerstore.
size_t signed_address_len
Signed address length.
enum GNUNET_NetworkType nt
Network type offered by this address.
struct GNUNET_PEERSTORE_StoreHelloContext * shc
Store hello handle.
const char * address
The actual address.

References AddressListEntry::address, env, GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_address_to_prefix(), GNUNET_HELLO_builder_add_address(), GNUNET_HELLO_builder_to_env(), GNUNET_HELLO_sign_address(), GNUNET_log, GNUNET_MQ_env_get_msg(), GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_hello_add(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_UNIT_ZERO, GST_my_hello, GST_my_private_key, hello_mono_time, msg, AddressListEntry::nt, peerstore, prefix, AddressListEntry::shc, shc_cont(), AddressListEntry::signed_address, AddressListEntry::signed_address_len, and AddressListEntry::st.

Referenced by create_address_entry(), peerstore_store_own_cb(), and shc_cont().

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

◆ peerstore_store_own_cb()

static void peerstore_store_own_cb ( void *  cls,
int  success 
)
static

Function called when peerstore is done storing our address.

Parameters
clsa struct AddressListEntry
successGNUNET_YES if peerstore was successful

Definition at line 5878 of file gnunet-service-transport.c.

5879{
5880 struct AddressListEntry *ale = cls;
5881
5882 ale->sc = NULL;
5883 if (GNUNET_YES != success)
5885 "Failed to store our own address `%s' in peerstore!\n",
5886 ale->address);
5887 else
5889 "Successfully stored our own address `%s' in peerstore!\n",
5890 ale->address);
5891 /* refresh period is 1/4 of expiration time, that should be plenty
5892 without being excessive. */
5893 ale->st =
5895 4ULL),
5896 &store_pi,
5897 ale);
5898}
static void store_pi(void *cls)
Ask peerstore to store our address.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_divide(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Divide relative time by a given factor.
Definition: time.c:552
struct GNUNET_TIME_Relative expiration
What is a typical lifetime the communicator expects this address to have? (Always from now....

References AddressListEntry::address, AddressListEntry::expiration, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_divide(), GNUNET_YES, AddressListEntry::sc, AddressListEntry::st, and store_pi().

Referenced by shc_cont().

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

◆ shc_cont()

static void shc_cont ( void *  cls,
int  success 
)
static

Definition at line 5902 of file gnunet-service-transport.c.

5903{
5904 struct AddressListEntry *ale = cls;
5906
5909 "transport",
5912 ale->signed_address,
5913 ale->signed_address_len,
5914 expiration,
5917 ale);
5918 if (NULL == ale->sc)
5919 {
5921 "Failed to store our address `%s' with peerstore\n",
5922 ale->address);
5924 &store_pi,
5925 ale);
5926 }
5927}
static struct GNUNET_TIME_Relative expiration
User supplied expiration value.
static void peerstore_store_own_cb(void *cls, int success)
Function called when peerstore is done storing our address.
struct GNUNET_PEERSTORE_StoreContext * GNUNET_PEERSTORE_store(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
Store a new entry in the PEERSTORE.
#define GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY
Key used for storing HELLOs in the peerstore.
@ GNUNET_PEERSTORE_STOREOPTION_MULTIPLE
Possibly store multiple values under given key.

References AddressListEntry::address, expiration, AddressListEntry::expiration, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_STOREOPTION_MULTIPLE, GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_SECONDS, GST_my_identity, peerstore, peerstore_store_own_cb(), AddressListEntry::sc, AddressListEntry::signed_address, AddressListEntry::signed_address_len, AddressListEntry::st, and store_pi().

Referenced by store_pi().

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

◆ create_address_entry()

static struct AddressListEntry * create_address_entry ( struct TransportClient tc,
struct GNUNET_TIME_Relative  expiration,
enum GNUNET_NetworkType  nt,
const char *  address,
uint32_t  aid,
size_t  slen 
)
static

Definition at line 6000 of file gnunet-service-transport.c.

6006{
6007 struct AddressListEntry *ale;
6008 char *address_without_port;
6009
6010 ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen);
6011 ale->tc = tc;
6012 ale->address = (const char *) &ale[1];
6013 ale->expiration = expiration;
6014 ale->aid = aid;
6015 ale->nt = nt;
6016 memcpy (&ale[1], address, slen);
6017 address_without_port = get_address_without_port (ale->address);
6019 "Is this %s a local address (%s)\n",
6020 address_without_port,
6021 ale->address);
6022 if (0 != strcmp ("127.0.0.1", address_without_port))
6023 ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
6024 GNUNET_free (address_without_port);
6025
6026 return ale;
6027}
static char * get_address_without_port(const char *address)
Get the IP address without the port number.
uint32_t aid
Address identifier used by the communicator.

References address, AddressListEntry::address, AddressListEntry::aid, expiration, AddressListEntry::expiration, get_address_without_port(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_SCHEDULER_add_now(), nt, AddressListEntry::nt, AddressListEntry::st, store_pi(), tc, and AddressListEntry::tc.

Referenced by handle_add_address().

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

◆ handle_add_address()

static void handle_add_address ( void *  cls,
const struct GNUNET_TRANSPORT_AddAddressMessage aam 
)
static

Address of our peer added.

Process the request.

Parameters
clsthe client
aamthe send message that was sent

Definition at line 6037 of file gnunet-service-transport.c.

6039{
6040 struct TransportClient *tc = cls;
6041 struct AddressListEntry *ale;
6042 size_t slen;
6043 char *address;
6044
6045 /* 0-termination of &aam[1] was checked in #check_add_address */
6047 "Communicator added address `%s'!\n",
6048 (const char *) &aam[1]);
6049 slen = ntohs (aam->header.size) - sizeof(*aam);
6050 address = GNUNET_malloc (slen);
6051 memcpy (address, &aam[1], slen);
6052 ale = create_address_entry (tc,
6054 ntohl (aam->nt),
6055 address,
6056 aam->aid,
6057 slen);
6058 GNUNET_CONTAINER_DLL_insert (tc->details.communicator.addr_head,
6059 tc->details.communicator.addr_tail,
6060 ale);
6063}
static struct AddressListEntry * create_address_entry(struct TransportClient *tc, struct GNUNET_TIME_Relative expiration, enum GNUNET_NetworkType nt, const char *address, uint32_t aid, size_t slen)
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:630
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS.
Definition: transport.h:291
struct GNUNET_TIME_RelativeNBO expiration
When does the address expire?
Definition: transport.h:301
uint32_t nt
An enum GNUNET_NetworkType in NBO.
Definition: transport.h:306
uint32_t aid
Address identifier (used during deletion).
Definition: transport.h:296

References address, GNUNET_TRANSPORT_AddAddressMessage::aid, create_address_entry(), GNUNET_TRANSPORT_AddAddressMessage::expiration, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_SERVICE_client_continue(), GNUNET_TIME_relative_ntoh(), GNUNET_TRANSPORT_AddAddressMessage::header, GNUNET_TRANSPORT_AddAddressMessage::nt, GNUNET_MessageHeader::size, and tc.

Here is the call graph for this function:

◆ handle_del_address()

static void handle_del_address ( void *  cls,
const struct GNUNET_TRANSPORT_DelAddressMessage dam 
)
static

Address of our peer deleted.

Process the request.

Parameters
clsthe client
damthe send message that was sent

Definition at line 6073 of file gnunet-service-transport.c.

6075{
6076 struct TransportClient *tc = cls;
6077 struct AddressListEntry *alen;
6078
6079 if (CT_COMMUNICATOR != tc->type)
6080 {
6081 GNUNET_break (0);
6083 return;
6084 }
6085 for (struct AddressListEntry *ale = tc->details.communicator.addr_head;
6086 NULL != ale;
6087 ale = alen)
6088 {
6089 alen = ale->next;
6090 if (dam->aid != ale->aid)
6091 continue;
6092 GNUNET_assert (ale->tc == tc);
6094 "Communicator deleted address `%s'!\n",
6095 ale->address);
6098 return;
6099 }
6101 "Communicator removed address we did not even have.\n");
6103 // GNUNET_SERVICE_client_drop (tc->client);
6104}
struct AddressListEntry * next
Kept in a DLL.
uint32_t aid
Address identifier.
Definition: transport.h:325

References GNUNET_TRANSPORT_DelAddressMessage::aid, CT_COMMUNICATOR, free_address_list_entry(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), AddressListEntry::next, and tc.

Here is the call graph for this function:

◆ demultiplex_with_cmc()

static void demultiplex_with_cmc ( struct CommunicatorMessageContext cmc)
static

Given an inbound message msg from a communicator cmc, demultiplex it based on the type calling the right handler.

Parameters
cmccontext for demultiplexing
msgmessage to demultiplex

Definition at line 10172 of file gnunet-service-transport.c.

10173{
10175 { GNUNET_MQ_hd_var_size (fragment_box,
10178 cmc),
10179 GNUNET_MQ_hd_var_size (reliability_box,
10182 cmc),
10183 GNUNET_MQ_hd_var_size (reliability_ack,
10186 cmc),
10187 GNUNET_MQ_hd_var_size (backchannel_encapsulation,
10190 cmc),
10191 GNUNET_MQ_hd_var_size (dv_learn,
10194 cmc),
10195 GNUNET_MQ_hd_var_size (dv_box,
10197 struct TransportDVBoxMessage,
10198 cmc),
10199 GNUNET_MQ_hd_var_size (flow_control,
10202 cmc),
10204 validation_challenge,
10207 cmc),
10209 validation_response,
10212 cmc),
10214 int ret;
10215 const struct GNUNET_MessageHeader *msg = cmc->mh;
10216
10218 "Handling message of type %u with %u bytes\n",
10219 (unsigned int) ntohs (msg->type),
10220 (unsigned int) ntohs (msg->size));
10222 if (GNUNET_SYSERR == ret)
10223 {
10224 GNUNET_break (0);
10226 GNUNET_free (cmc);
10227 return;
10228 }
10229 if (GNUNET_NO == ret)
10230 {
10231 /* unencapsulated 'raw' message */
10232 handle_raw_message (cmc, msg);
10233 }
10234}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
static void handle_raw_message(void *cls, const struct GNUNET_MessageHeader *mh)
Communicator gave us an unencapsulated message to pass as-is to CORE.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
enum GNUNET_GenericReturnValue GNUNET_MQ_handle_message(const struct GNUNET_MQ_MessageHandler *handlers, const struct GNUNET_MessageHeader *mh)
Call the message message handler that was registered for the type of the given message in the given h...
Definition: mq.c:205
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE
P2P message: transport requests confirmation that an address works.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT
Type of a fragment of a CORE message created by transport to adjust message length to a queue's MTU.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX
Wrapper around non-fragmented CORE message used to measure RTT and ensure reliability.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN
Message sent for topology discovery at transport level.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE
P2P message: transport proves that an address worked.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK
Confirmation for a GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX.
const struct GNUNET_MessageHeader * mh
The message to demultiplex.
Message handler for a specific message type.
Internal message used by transport for distance vector learning.
Confirmation that the receiver got a GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX.
Outer layer of an encapsulated unfragmented application message sent over an unreliable channel.
Message send to another peer to validate that it can indeed receive messages at a particular address.
Message send to a peer to respond to a #GNUNET_MESSAGE_TYPE_ADDRESS_VALIDATION_CHALLENGE.

References TransportClient::client, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE, GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN, GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL, GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT, GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK, GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX, GNUNET_MQ_handle_message(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, handle_raw_message(), handlers, CommunicatorMessageContext::mh, msg, ret, GNUNET_MessageHeader::size, CommunicatorMessageContext::tc, and GNUNET_MessageHeader::type.

Referenced by backtalker_monotime_cb(), handle_dv_box(), handle_fragment_box(), handle_incoming_msg(), and handle_reliability_box().

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

◆ core_env_sent_cb()

static void core_env_sent_cb ( void *  cls)
static

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.

Parameters
clsa struct CoreSentContext

Definition at line 6126 of file gnunet-service-transport.c.

6127{
6128 struct CoreSentContext *ctx = cls;
6129 struct VirtualLink *vl = ctx->vl;
6130
6131 if (NULL == vl)
6132 {
6133 /* lost the link in the meantime, ignore */
6134 GNUNET_free (ctx);
6135 return;
6136 }
6139 vl->incoming_fc_window_size_ram -= ctx->size;
6140 vl->incoming_fc_window_size_used += ctx->isize;
6142 GNUNET_free (ctx);
6143}

References consider_sending_fc(), VirtualLink::csc_head, VirtualLink::csc_tail, ctx, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, VirtualLink::incoming_fc_window_size_ram, and VirtualLink::incoming_fc_window_size_used.

Referenced by finish_handling_raw_message().

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

◆ finish_handling_raw_message()

static void finish_handling_raw_message ( struct VirtualLink vl,
const struct GNUNET_MessageHeader mh,
struct CommunicatorMessageContext cmc,
unsigned int  free_cmc 
)
static

Definition at line 6147 of file gnunet-service-transport.c.

6151{
6152 uint16_t size = ntohs (mh->size);
6153 int have_core;
6154
6155 if (vl->incoming_fc_window_size_ram > UINT_MAX - size)
6156 {
6158 "# CORE messages dropped (FC arithmetic overflow)",
6159 1,
6160 GNUNET_NO);
6162 "CORE messages of type %u with %u bytes dropped (FC arithmetic overflow)\n",
6163 (unsigned int) ntohs (mh->type),
6164 (unsigned int) ntohs (mh->size));
6165 if (GNUNET_YES == free_cmc)
6167 return;
6168 }
6170 {
6172 "# CORE messages dropped (FC window overflow)",
6173 1,
6174 GNUNET_NO);
6176 "CORE messages of type %u with %u bytes dropped (FC window overflow)\n",
6177 (unsigned int) ntohs (mh->type),
6178 (unsigned int) ntohs (mh->size));
6179 if (GNUNET_YES == free_cmc)
6181 return;
6182 }
6183
6184 /* Forward to all CORE clients */
6185 have_core = GNUNET_NO;
6186 for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
6187 {
6188 struct GNUNET_MQ_Envelope *env;
6189 struct InboundMessage *im;
6190 struct CoreSentContext *ctx;
6191
6192 if (CT_CORE != tc->type)
6193 continue;
6196 ctx = GNUNET_new (struct CoreSentContext);
6197 ctx->vl = vl;
6198 ctx->size = size;
6199 ctx->isize = (GNUNET_NO == have_core) ? size : 0;
6200 have_core = GNUNET_YES;
6203 im->peer = cmc->im.sender;
6204 memcpy (&im[1], mh, size);
6205 GNUNET_MQ_send (tc->mq, env);
6207 }
6208 if (GNUNET_NO == have_core)
6209 {
6211 "Dropped message to CORE: no CORE client connected!\n");
6212 /* Nevertheless, count window as used, as it is from the
6213 perspective of the other peer! */
6215 /* TODO-M1 */
6217 "Dropped message of type %u with %u bytes to CORE: no CORE client connected!\n",
6218 (unsigned int) ntohs (mh->type),
6219 (unsigned int) ntohs (mh->size));
6220 if (GNUNET_YES == free_cmc)
6222 return;
6223 }
6225 "Delivered message from %s of type %u to CORE recv window %d\n",
6226 GNUNET_i2s (&cmc->im.sender),
6227 ntohs (mh->type),
6229 if (vl->core_recv_window > 0)
6230 {
6231 if (GNUNET_YES == free_cmc)
6233 return;
6234 }
6235 /* Wait with calling #finish_cmc_handling(cmc) until the message
6236 was processed by CORE MQs (for CORE flow control)! */
6237 if (GNUNET_YES == free_cmc)
6239}
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
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...
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:655
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
Message from TRANSPORT notifying about a message that was received.
struct GNUNET_PeerIdentity sender
Sender identifier.
Definition: transport.h:358
Message used to notify the transport API about a message received from the network.
Definition: transport.h:143
struct GNUNET_PeerIdentity peer
Which peer sent the message?
Definition: transport.h:152

References VirtualLink::available_fc_window_size, clients_head, VirtualLink::cmc_head, VirtualLink::cmc_tail, core_env_sent_cb(), VirtualLink::core_recv_window, VirtualLink::csc_head, VirtualLink::csc_tail, CT_CORE, ctx, env, finish_cmc_handling_with_continue(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GST_stats, CommunicatorMessageContext::im, VirtualLink::incoming_fc_window_size_ram, VirtualLink::incoming_fc_window_size_used, mh, InboundMessage::peer, GNUNET_TRANSPORT_IncomingMessage::sender, size, tc, and CoreSentContext::vl.

Referenced by handle_raw_message(), and send_msg_from_cache().

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

◆ handle_raw_message()

static void handle_raw_message ( void *  cls,
const struct GNUNET_MessageHeader mh 
)
static

Communicator gave us an unencapsulated message to pass as-is to CORE.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
mhthe message that was received

Definition at line 6251 of file gnunet-service-transport.c.

6252{
6253 struct CommunicatorMessageContext *cmc = cls;
6254 // struct CommunicatorMessageContext *cmc_copy =
6255 // GNUNET_new (struct CommunicatorMessageContext);
6256 struct GNUNET_MessageHeader *mh_copy;
6257 struct RingBufferEntry *rbe;
6258 struct VirtualLink *vl;
6259 uint16_t size = ntohs (mh->size);
6260
6262 "Handling raw message of type %u with %u bytes\n",
6263 (unsigned int) ntohs (mh->type),
6264 (unsigned int) ntohs (mh->size));
6265
6266 if ((size > UINT16_MAX - sizeof(struct InboundMessage)) ||
6267 (size < sizeof(struct GNUNET_MessageHeader)))
6268 {
6269 struct GNUNET_SERVICE_Client *client = cmc->tc->client;
6270
6271 GNUNET_break (0);
6272 finish_cmc_handling (cmc);
6274 return;
6275 }
6276 vl = lookup_virtual_link (&cmc->im.sender);
6277 if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
6278 {
6279 /* FIXME: sender is giving us messages for CORE but we don't have
6280 the link up yet! I *suspect* this can happen right now (i.e.
6281 sender has verified us, but we didn't verify sender), but if
6282 we pass this on, CORE would be confused (link down, messages
6283 arrive). We should investigate more if this happens often,
6284 or in a persistent manner, and possibly do "something" about
6285 it. Thus logging as error for now. */
6286
6287 mh_copy = GNUNET_malloc (size);
6288 rbe = GNUNET_new (struct RingBufferEntry);
6289 rbe->cmc = cmc;
6290 /*cmc_copy->tc = cmc->tc;
6291 cmc_copy->im = cmc->im;*/
6292 GNUNET_memcpy (mh_copy, mh, size);
6293
6294 rbe->mh = mh_copy;
6295
6297 {
6298 struct RingBufferEntry *rbe_old = ring_buffer[ring_buffer_head];
6299 GNUNET_free (rbe_old->cmc);
6300 GNUNET_free (rbe_old->mh);
6301 GNUNET_free (rbe_old);
6302 }
6303 ring_buffer[ring_buffer_head] = rbe;// cmc_copy;
6304 // cmc_copy->mh = (const struct GNUNET_MessageHeader *) mh_copy;
6305 cmc->mh = (const struct GNUNET_MessageHeader *) mh_copy;
6307 "Storing message for %s and type %u (%u) in ring buffer head %u is full %u\n",
6308 GNUNET_i2s (&cmc->im.sender),
6309 (unsigned int) ntohs (mh->type),
6310 (unsigned int) ntohs (mh_copy->type),
6314 {
6315 ring_buffer_head = 0;
6317 }
6318 else
6320
6322 "%u items stored in ring buffer\n",
6325
6326 /*GNUNET_break_op (0);
6327 GNUNET_STATISTICS_update (GST_stats,
6328 "# CORE messages dropped (virtual link still down)",
6329 1,
6330 GNUNET_NO);
6331
6332 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
6333 "CORE messages of type %u with %u bytes dropped (virtual link still down)\n",
6334 (unsigned int) ntohs (mh->type),
6335 (unsigned int) ntohs (mh->size));
6336 finish_cmc_handling (cmc);*/
6339 // GNUNET_free (cmc);
6340 return;
6341 }
6343}
static unsigned int is_ring_buffer_full
Is the ring buffer filled up to RING_BUFFER_SIZE.
static void finish_cmc_handling(struct CommunicatorMessageContext *cmc)
static void finish_handling_raw_message(struct VirtualLink *vl, const struct GNUNET_MessageHeader *mh, struct CommunicatorMessageContext *cmc, unsigned int free_cmc)
#define RING_BUFFER_SIZE
Size of ring buffer to cache CORE and forwarded DVBox messages.
static unsigned int ring_buffer_head
Head of the ring buffer.
static struct RingBufferEntry * ring_buffer[RING_BUFFER_SIZE]
Ring buffer for a CORE message we did not deliver to CORE, because of missing virtual link to sender.
Handle to a client that is connected to a service.
Definition: service.c:249
Entry for the ring buffer caching messages send to core, when virtual link is available.
struct CommunicatorMessageContext * cmc
Communicator context for this ring buffer entry.
struct GNUNET_MessageHeader * mh
The message in this entry.

References TransportClient::client, RingBufferEntry::cmc, VirtualLink::confirmed, CommunicatorMessageContext::continue_send, finish_cmc_handling(), finish_cmc_handling_with_continue(), finish_handling_raw_message(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_SERVICE_client_drop(), GNUNET_YES, CommunicatorMessageContext::im, is_ring_buffer_full, lookup_virtual_link(), mh, CommunicatorMessageContext::mh, RingBufferEntry::mh, ring_buffer, ring_buffer_head, RING_BUFFER_SIZE, GNUNET_TRANSPORT_IncomingMessage::sender, size, CommunicatorMessageContext::tc, and GNUNET_MessageHeader::type.

Referenced by demultiplex_with_cmc().

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

◆ check_fragment_box()

static int check_fragment_box ( void *  cls,
const struct TransportFragmentBoxMessage fb 
)
static

Communicator gave us a fragment box.

Check the message.

Parameters
clsa struct CommunicatorMessageContext
fbthe send message that was sent
Returns
GNUNET_YES if message is well-formed

Definition at line 6354 of file gnunet-service-transport.c.

6355{
6356 uint16_t size = ntohs (fb->header.size);
6357 uint16_t bsize = size - sizeof(*fb);
6358
6359 (void) cls;
6360 if (0 == bsize)
6361 {
6362 GNUNET_break_op (0);
6363 return GNUNET_SYSERR;
6364 }
6365 if (bsize + ntohs (fb->frag_off) > ntohs (fb->msg_size))
6366 {
6367 GNUNET_break_op (0);
6368 return GNUNET_SYSERR;
6369 }
6370 if (ntohs (fb->frag_off) >= ntohs (fb->msg_size))
6371 {
6372 GNUNET_break_op (0);
6373 return GNUNET_SYSERR;
6374 }
6375 return GNUNET_YES;
6376}
static unsigned int bsize
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT.

References bsize, TransportFragmentBoxMessage::frag_off, GNUNET_break_op, GNUNET_SYSERR, GNUNET_YES, TransportFragmentBoxMessage::header, TransportFragmentBoxMessage::msg_size, GNUNET_MessageHeader::size, and size.

◆ destroy_ack_cummulator()

static void destroy_ack_cummulator ( void *  cls)
static

Clean up an idle cumulative acknowledgement data structure.

Parameters
clsa struct AcknowledgementCummulator *

Definition at line 6385 of file gnunet-service-transport.c.

6386{
6387 struct AcknowledgementCummulator *ac = cls;
6388
6389 ac->task = NULL;
6390 GNUNET_assert (0 == ac->num_acks);
6392 GNUNET_YES ==
6394 GNUNET_free (ac);
6395}
Data structure in which we track acknowledgements still to be sent to the.
struct GNUNET_SCHEDULER_Task * task
Task scheduled either to transmit the cumulative ACK message, or to clean up this data structure afte...
struct GNUNET_PeerIdentity target
Target peer for which we are accumulating ACKs here.
unsigned int num_acks
Number of entries used in ack_uuids.

References ack_cummulators, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_YES, AcknowledgementCummulator::num_acks, AcknowledgementCummulator::target, and AcknowledgementCummulator::task.

Referenced by transmit_cummulative_ack_cb().

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

◆ transmit_cummulative_ack_cb()

static void transmit_cummulative_ack_cb ( void *  cls)
static

Do the transmission of a cumulative acknowledgement now.

Parameters
clsa struct AcknowledgementCummulator *

Definition at line 6404 of file gnunet-service-transport.c.

6405{
6406 struct Neighbour *n;
6407 struct VirtualLink *vl;
6408 struct AcknowledgementCummulator *ac = cls;
6409 char buf[sizeof(struct TransportReliabilityAckMessage)
6410 + ac->num_acks
6412 struct TransportReliabilityAckMessage *ack =
6413 (struct TransportReliabilityAckMessage *) buf;
6415
6416 ac->task = NULL;
6418 "Sending ACK with %u components to %s\n",
6419 ac->num_acks,
6420 GNUNET_i2s (&ac->target));
6421 GNUNET_assert (0 < ac->num_acks);
6423 ack->header.size =
6424 htons (sizeof(*ack)
6425 + ac->num_acks * sizeof(struct TransportCummulativeAckPayloadP));
6426 ack->ack_counter = htonl (ac->ack_counter += ac->num_acks);
6427 ap = (struct TransportCummulativeAckPayloadP *) &ack[1];
6428 for (unsigned int i = 0; i < ac->num_acks; i++)
6429 {
6430 ap[i].ack_uuid = ac->ack_uuids[i].ack_uuid;
6433 }
6434 /*route_control_message_without_fc (
6435 &ac->target,
6436 &ack->header,
6437 RMO_DV_ALLOWED);*/
6438 vl = lookup_virtual_link (&ac->target);
6439 if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
6440 {
6442 vl,
6443 &ack->header,
6445 }
6446 else
6447 {
6448 /* Use route via neighbour */
6449 n = lookup_neighbour (&ac->target);
6450 if (NULL != n)
6452 n,
6453 &ack->header,
6454 RMO_NONE);
6455 }
6456 ac->num_acks = 0;
6459 ac);
6460}
#define ACK_CUMMULATOR_TIMEOUT
How long until we forget about historic accumulators and thus reset the ACK counter?...
static void destroy_ack_cummulator(void *cls)
Clean up an idle cumulative acknowledgement data structure.
struct TransportCummulativeAckPayload ack_uuids[64]
ACK data being accumulated.
uint32_t ack_counter
Counter to produce the ack_counter in the struct TransportReliabilityAckMessage.
struct GNUNET_TIME_RelativeNBO ack_delay
How long was the ACK delayed for generating cumulative ACKs? Used to calculate the correct network RT...
struct AcknowledgementUUIDP ack_uuid
UUID of a message being acknowledged.
struct GNUNET_TIME_Absolute receive_time
When did we receive the message we are ACKing? Used to calculate the delay we introduced by cummulati...
struct AcknowledgementUUIDP ack_uuid
UUID of a message being acknowledged.
uint32_t ack_counter
Counter of ACKs transmitted by the sender to us.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK.

References TransportReliabilityAckMessage::ack_counter, AcknowledgementCummulator::ack_counter, ACK_CUMMULATOR_TIMEOUT, TransportCummulativeAckPayloadP::ack_delay, TransportCummulativeAckPayloadP::ack_uuid, TransportCummulativeAckPayload::ack_uuid, AcknowledgementCummulator::ack_uuids, VirtualLink::confirmed, destroy_ack_cummulator(), GNUNET_ALIGN, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_hton(), GNUNET_YES, TransportReliabilityAckMessage::header, lookup_neighbour(), lookup_virtual_link(), AcknowledgementCummulator::num_acks, TransportCummulativeAckPayload::receive_time, RMO_DV_ALLOWED, RMO_NONE, route_control_message_without_fc(), route_via_neighbour(), GNUNET_MessageHeader::size, AcknowledgementCummulator::target, AcknowledgementCummulator::task, and GNUNET_MessageHeader::type.

Referenced by cummulative_ack().

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

◆ cummulative_ack()

static void cummulative_ack ( const struct GNUNET_PeerIdentity pid,
const struct AcknowledgementUUIDP ack_uuid,
struct GNUNET_TIME_Absolute  max_delay 
)
static

Transmit an acknowledgement for ack_uuid to pid delaying transmission by at most ack_delay.

Parameters
pidtarget peer
ack_uuidUUID to ack
max_delayhow long can the ACK wait

Definition at line 6472 of file gnunet-service-transport.c.

6475{
6476 struct AcknowledgementCummulator *ac;
6477
6479 "Scheduling ACK %s for transmission to %s\n",
6480 GNUNET_uuid2s (&ack_uuid->value),
6481 GNUNET_i2s (pid));
6483 if (NULL == ac)
6484 {
6486 ac->target = *pid;
6487 ac->min_transmission_time = max_delay;
6491 &ac->target,
6492 ac,
6494 }
6495 else
6496 {
6497 if (MAX_CUMMULATIVE_ACKS == ac->num_acks)
6498 {
6499 /* must run immediately, ack buffer full! */
6501 }
6505 }
6508 ac->ack_uuids[ac->num_acks].ack_uuid = *ack_uuid;
6509 ac->num_acks++;
6512 ac);
6513}
#define MAX_CUMMULATIVE_ACKS
Maximum number of messages we acknowledge together in one cumulative ACK.
static void transmit_cummulative_ack_cb(void *cls)
Do the transmission of a cumulative acknowledgement now.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_min(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the minimum of two absolute time values.
Definition: time.c:360
struct GNUNET_TIME_Absolute min_transmission_time
When is task run (only used if num_acks is non-zero)?

References ack_cummulators, TransportCummulativeAckPayload::ack_uuid, AcknowledgementCummulator::ack_uuids, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_min(), GNUNET_uuid2s(), GNUNET_YES, MAX_CUMMULATIVE_ACKS, AcknowledgementCummulator::min_transmission_time, AcknowledgementCummulator::num_acks, pid, TransportCummulativeAckPayload::receive_time, AcknowledgementCummulator::target, AcknowledgementCummulator::task, transmit_cummulative_ack_cb(), and AcknowledgementUUIDP::value.

Referenced by handle_fragment_box(), and handle_reliability_box().

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

◆ find_by_message_uuid()

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

Iterator called to find a reassembly context by the message UUID in the multihashmap32.

Parameters
clsa struct FindByMessageUuidContext
keya key (unused)
valuea struct ReassemblyContext
Returns
GNUNET_YES if not found, GNUNET_NO if found

Definition at line 6543 of file gnunet-service-transport.c.

6544{
6545 struct FindByMessageUuidContext *fc = cls;
6546 struct ReassemblyContext *rc = value;
6547
6548 (void) key;
6549 if (0 == GNUNET_memcmp (&fc->message_uuid, &rc->msg_uuid))
6550 {
6551 fc->rc = rc;
6552 return GNUNET_NO;
6553 }
6554 return GNUNET_YES;
6555}
Closure for find_by_message_uuid.
struct ReassemblyContext * rc
Set to the reassembly context if found.
struct MessageUUIDP message_uuid
UUID to look for.

References GNUNET_memcmp, GNUNET_NO, GNUNET_YES, key, FindByMessageUuidContext::message_uuid, ReassemblyContext::msg_uuid, FindByMessageUuidContext::rc, and value.

Referenced by handle_fragment_box().

Here is the caller graph for this function:

◆ handle_fragment_box()

static void handle_fragment_box ( void *  cls,
const struct TransportFragmentBoxMessage fb 
)
static

Communicator gave us a fragment.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
fbthe message that was received

Definition at line 6566 of file gnunet-service-transport.c.

6567{
6568 struct CommunicatorMessageContext *cmc = cls;
6569 struct VirtualLink *vl;
6570 struct ReassemblyContext *rc;
6571 const struct GNUNET_MessageHeader *msg;
6572 uint16_t msize;
6573 uint16_t fsize;
6574 uint16_t frag_off;
6575 char *target;
6576 struct GNUNET_TIME_Relative cdelay;
6577 struct FindByMessageUuidContext fc;
6578
6579 vl = lookup_virtual_link (&cmc->im.sender);
6580 if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
6581 {
6582 struct GNUNET_SERVICE_Client *client = cmc->tc->client;
6583
6585 "No virtual link for %s to handle fragment\n",
6586 GNUNET_i2s (&cmc->im.sender));
6587 GNUNET_break (0);
6588 finish_cmc_handling (cmc);
6590 return;
6591 }
6592 if (NULL == vl->reassembly_map)
6593 {
6595 vl->reassembly_heap =
6600 vl);
6601 }
6602 msize = ntohs (fb->msg_size);
6603 fc.message_uuid = fb->msg_uuid;
6604 fc.rc = NULL;
6606 fb->msg_uuid.uuid,
6608 &fc);
6609 fsize = ntohs (fb->header.size) - sizeof(*fb);
6610 if (NULL == (rc = fc.rc))
6611 {
6612 rc = GNUNET_malloc (sizeof(*rc) + msize /* reassembly payload buffer */
6613 + (msize + 7) / 8 * sizeof(uint8_t) /* bitfield */);
6614 rc->msg_uuid = fb->msg_uuid;
6615 rc->virtual_link = vl;
6616 rc->msg_size = msize;
6617 rc->reassembly_timeout =
6621 rc,
6625 vl->reassembly_map,
6626 rc->msg_uuid.uuid,
6627 rc,
6629 target = (char *) &rc[1];
6630 rc->bitfield = (uint8_t *) (target + rc->msg_size);
6631 if (fsize != rc->msg_size)
6632 rc->msg_missing = rc->msg_size;
6633 else
6634 rc->msg_missing = 0;
6636 "Received fragment with size %u at offset %u/%u %u bytes missing from %s for NEW message %"
6637 PRIu64 "\n",
6638 fsize,
6639 ntohs (fb->frag_off),
6640 msize,
6641 rc->msg_missing,
6642 GNUNET_i2s (&cmc->im.sender),
6643 fb->msg_uuid.uuid);
6644 }
6645 else
6646 {
6647 target = (char *) &rc[1];
6649 "Received fragment at offset %u/%u from %s for message %u\n",
6650 ntohs (fb->frag_off),
6651 msize,
6652 GNUNET_i2s (&cmc->im.sender),
6653 (unsigned int) fb->msg_uuid.uuid);
6654 }
6655 if (msize != rc->msg_size)
6656 {
6657 GNUNET_break (0);
6658 finish_cmc_handling (cmc);
6659 return;
6660 }
6661
6662 /* reassemble */
6663 if (0 == fsize)
6664 {
6665 GNUNET_break (0);
6666 finish_cmc_handling (cmc);
6667 return;
6668 }
6669 frag_off = ntohs (fb->frag_off);
6670 if (frag_off + fsize > msize)
6671 {
6672 /* Fragment (plus fragment size) exceeds message size! */
6673 GNUNET_break_op (0);
6674 finish_cmc_handling (cmc);
6675 return;
6676 }
6677 memcpy (&target[frag_off], &fb[1], fsize);
6678 /* update bitfield and msg_missing */
6679 for (unsigned int i = frag_off; i < frag_off + fsize; i++)
6680 {
6681 if (0 == (rc->bitfield[i / 8] & (1 << (i % 8))))
6682 {
6683 rc->bitfield[i / 8] |= (1 << (i % 8));
6684 rc->msg_missing--;
6685 }
6686 }
6687
6688 /* Compute cumulative ACK */
6690 cdelay = GNUNET_TIME_relative_multiply (cdelay, rc->msg_missing / fsize);
6691 if (0 == rc->msg_missing)
6692 cdelay = GNUNET_TIME_UNIT_ZERO;
6693 cummulative_ack (&cmc->im.sender,
6694 &fb->ack_uuid,
6697 /* is reassembly complete? */
6698 if (0 != rc->msg_missing)
6699 {
6700 finish_cmc_handling (cmc);
6701 return;
6702 }
6703 /* reassembly is complete, verify result */
6704 msg = (const struct GNUNET_MessageHeader *) &rc[1];
6705 if (ntohs (msg->size) != rc->msg_size)
6706 {
6707 GNUNET_break (0);
6709 finish_cmc_handling (cmc);
6710 return;
6711 }
6712 /* successful reassembly */
6714 "Fragment reassembly complete for message %u\n",
6715 (unsigned int) fb->msg_uuid.uuid);
6716 /* FIXME: check that the resulting msg is NOT a
6717 DV Box or Reliability Box, as that is NOT allowed! */
6718 cmc->mh = msg;
6720 /* FIXME-OPTIMIZE: really free here? Might be bad if fragments are still
6721 en-route and we forget that we finished this reassembly immediately!
6722 -> keep around until timeout?
6723 -> shorten timeout based on ACK? */
6725}
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.
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.
#define REASSEMBLY_EXPIRATION
How long do we keep partially reassembled messages around before giving up?
static void demultiplex_with_cmc(struct CommunicatorMessageContext *cmc)
Given an inbound message msg from a communicator cmc, demultiplex it based on the type calling the ri...
int GNUNET_CONTAINER_multihashmap32_get_multiple(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, GNUNET_CONTAINER_MultiHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
struct GNUNET_CONTAINER_HeapNode * GNUNET_CONTAINER_heap_insert(struct GNUNET_CONTAINER_Heap *heap, void *element, GNUNET_CONTAINER_HeapCostType cost)
Inserts a new element into the heap.
struct GNUNET_CONTAINER_Heap * GNUNET_CONTAINER_heap_create(enum GNUNET_CONTAINER_HeapOrder order)
Create a new heap.
@ GNUNET_CONTAINER_HEAP_ORDER_MIN
Heap with the minimum cost at the root.
struct GNUNET_TIME_Absolute last_frag
Time we received the last fragment.
uint8_t * bitfield
Bitfield with msg_size bits representing the positions where we have received fragments.
uint16_t msg_size
How big is the message we are reassembling in total?
uint16_t msg_missing
How many bytes of the message are still missing? Defragmentation is complete when msg_missing == 0.
uint16_t frag_off
Offset of this fragment in the overall message.
struct MessageUUIDP msg_uuid
Original message ID for of the message that all the fragments belong to.
struct AcknowledgementUUIDP ack_uuid
Unique ID of this fragment (and fragment transmission!).
uint16_t msg_size
Total size of the message that is being fragmented.

References GNUNET_TIME_Absolute::abs_value_us, TransportFragmentBoxMessage::ack_uuid, ReassemblyContext::bitfield, TransportClient::client, VirtualLink::confirmed, cummulative_ack(), demultiplex_with_cmc(), find_by_message_uuid(), finish_cmc_handling(), TransportFragmentBoxMessage::frag_off, free_reassembly_context(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_drop(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_ZERO, TransportFragmentBoxMessage::header, ReassemblyContext::hn, CommunicatorMessageContext::im, ReassemblyContext::last_frag, lookup_virtual_link(), FindByMessageUuidContext::message_uuid, CommunicatorMessageContext::mh, msg, ReassemblyContext::msg_missing, TransportFragmentBoxMessage::msg_size, ReassemblyContext::msg_size, TransportFragmentBoxMessage::msg_uuid, ReassemblyContext::msg_uuid, FindByMessageUuidContext::rc, reassembly_cleanup_task(), REASSEMBLY_EXPIRATION, VirtualLink::reassembly_heap, VirtualLink::reassembly_map, ReassemblyContext::reassembly_timeout, VirtualLink::reassembly_timeout_task, GNUNET_TRANSPORT_IncomingMessage::sender, GNUNET_MessageHeader::size, CommunicatorMessageContext::tc, MessageUUIDP::uuid, and ReassemblyContext::virtual_link.

Here is the call graph for this function:

◆ check_reliability_box()

static int check_reliability_box ( void *  cls,
const struct TransportReliabilityBoxMessage rb 
)
static

Communicator gave us a reliability box.

Check the message.

Parameters
clsa struct CommunicatorMessageContext
rbthe send message that was sent
Returns
GNUNET_YES if message is well-formed

Definition at line 6736 of file gnunet-service-transport.c.

6738{
6739 const struct GNUNET_MessageHeader *box = (const struct
6740 GNUNET_MessageHeader *) &rb[1];
6741 (void) cls;
6742
6744 "check_send_msg with size %u: inner msg type %u and size %u (%lu %lu)\n",
6745 ntohs (rb->header.size),
6746 ntohs (box->type),
6747 ntohs (box->size),
6748 sizeof (struct TransportReliabilityBoxMessage),
6749 sizeof (struct GNUNET_MessageHeader));
6751 return GNUNET_YES;
6752}
#define GNUNET_MQ_check_boxed_message(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_check_boxed_message, GNUNET_YES, TransportReliabilityBoxMessage::header, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

◆ handle_reliability_box()

static void handle_reliability_box ( void *  cls,
const struct TransportReliabilityBoxMessage rb 
)
static

Communicator gave us a reliability box.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
rbthe message that was received

Definition at line 6763 of file gnunet-service-transport.c.

6765{
6766 struct CommunicatorMessageContext *cmc = cls;
6767 const struct GNUNET_MessageHeader *inbox =
6768 (const struct GNUNET_MessageHeader *) &rb[1];
6769 struct GNUNET_TIME_Relative rtt;
6770
6772 "Received reliability box from %s with UUID %s of type %u\n",
6773 GNUNET_i2s (&cmc->im.sender),
6775 (unsigned int) ntohs (inbox->type));
6776 rtt = GNUNET_TIME_UNIT_SECONDS; /* FIXME: should base this on "RTT", but we
6777 do not really have an RTT for the
6778 * incoming* queue (should we have
6779 the sender add it to the rb message?) */
6781 &cmc->im.sender,
6782 &rb->ack_uuid,
6783 (0 == ntohl (rb->ack_countdown))
6786 GNUNET_TIME_relative_divide (rtt, 8 /* FIXME: magic constant */)));
6787 /* continue with inner message */
6788 /* FIXME: check that inbox is NOT a DV Box, fragment or another
6789 reliability box (not allowed!) */
6790 cmc->mh = inbox;
6792}
uint32_t ack_countdown
Number of messages still to be sent before a commulative ACK is requested.
struct AcknowledgementUUIDP ack_uuid
Unique ID of the message used for signalling receipt of messages sent over possibly unreliable channe...

References TransportReliabilityBoxMessage::ack_countdown, TransportReliabilityBoxMessage::ack_uuid, cummulative_ack(), demultiplex_with_cmc(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_uuid2s(), CommunicatorMessageContext::im, CommunicatorMessageContext::mh, GNUNET_TRANSPORT_IncomingMessage::sender, GNUNET_MessageHeader::type, and AcknowledgementUUIDP::value.

Here is the call graph for this function:

◆ update_pd_age()

static void update_pd_age ( struct PerformanceData pd,
unsigned int  age 
)
static

Check if we have advanced to another age since the last time.

If so, purge ancient statistics (more than GOODPUT_AGING_SLOTS before the current age)

Parameters
[in,out]pddata to update
agecurrent age

Definition at line 6804 of file gnunet-service-transport.c.

6805{
6806 unsigned int sage;
6807
6808 if (age == pd->last_age)
6809 return; /* nothing to do */
6810 sage = GNUNET_MAX (pd->last_age, age - 2 * GOODPUT_AGING_SLOTS);
6811 for (unsigned int i = sage; i <= age - GOODPUT_AGING_SLOTS; i++)
6812 {
6813 struct TransmissionHistoryEntry *the = &pd->the[i % GOODPUT_AGING_SLOTS];
6814
6815 the->bytes_sent = 0;
6816 the->bytes_received = 0;
6817 }
6818 pd->last_age = age;
6819}
#define GOODPUT_AGING_SLOTS
Number of slots we keep of historic data for computation of goodput / message loss ratio.
#define GNUNET_MAX(a, b)
struct TransmissionHistoryEntry the[4]
Historic performance data, using a ring buffer of::GOODPUT_AGING_SLOTS entries.
unsigned int last_age
What was the last age when we wrote to the? Used to clear old entries when the age advances.
Information we keep per GOODPUT_AGING_SLOTS about historic (or current) transmission performance.
uint64_t bytes_received
Number of bytes received and acknowledged by the other peer in the interval.
uint64_t bytes_sent
Number of bytes actually sent in the interval.

References TransmissionHistoryEntry::bytes_received, TransmissionHistoryEntry::bytes_sent, GNUNET_MAX, GOODPUT_AGING_SLOTS, PerformanceData::last_age, and PerformanceData::the.

Referenced by update_performance_data().

Here is the caller graph for this function:

◆ update_performance_data()

static void update_performance_data ( struct PerformanceData pd,
struct GNUNET_TIME_Relative  rtt,
uint16_t  bytes_transmitted_ok 
)
static

Update pd based on the latest rtt and the number of bytes that were confirmed to be successfully transmitted.

Parameters
[in,out]pddata to update
rttlatest round-trip time
bytes_transmitted_oknumber of bytes receiver confirmed as received

Definition at line 6831 of file gnunet-service-transport.c.

6834{
6835 uint64_t nval = rtt.rel_value_us;
6836 uint64_t oval = pd->aged_rtt.rel_value_us;
6837 unsigned int age = get_age ();
6838 struct TransmissionHistoryEntry *the = &pd->the[age % GOODPUT_AGING_SLOTS];
6839
6840 if (oval == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
6841 pd->aged_rtt = rtt;
6842 else
6843 pd->aged_rtt.rel_value_us = (nval + 7 * oval) / 8;
6844 update_pd_age (pd, age);
6845 the->bytes_received += bytes_transmitted_ok;
6846}
static unsigned int get_age()
Get an offset into the transmission history buffer for struct PerformanceData.
static void update_pd_age(struct PerformanceData *pd, unsigned int age)
Check if we have advanced to another age since the last time.

References PerformanceData::aged_rtt, TransmissionHistoryEntry::bytes_received, get_age(), GNUNET_TIME_UNIT_FOREVER_REL, GOODPUT_AGING_SLOTS, GNUNET_TIME_Relative::rel_value_us, PerformanceData::the, and update_pd_age().

Referenced by update_dvh_performance(), and update_queue_performance().

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

◆ update_queue_performance()

static void update_queue_performance ( struct Queue q,
struct GNUNET_TIME_Relative  rtt,
uint16_t  bytes_transmitted_ok 
)
static

We have successfully transmitted data via q, update metrics.

Parameters
qqueue to update
rttround trip time observed
bytes_transmitted_oknumber of bytes successfully transmitted

Definition at line 6857 of file gnunet-service-transport.c.

6860{
6861 update_performance_data (&q->pd, rtt, bytes_transmitted_ok);
6862}
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 tran...

References q, and update_performance_data().

Referenced by handle_acknowledged().

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

◆ update_dvh_performance()

static void update_dvh_performance ( struct DistanceVectorHop dvh,
struct GNUNET_TIME_Relative  rtt,
uint16_t  bytes_transmitted_ok 
)
static

We have successfully transmitted data via dvh, update metrics.

Parameters
dvhdistance vector path data to update
rttround trip time observed
bytes_transmitted_oknumber of bytes successfully transmitted

Definition at line 6873 of file gnunet-service-transport.c.

6876{
6877 update_performance_data (&dvh->pd, rtt, bytes_transmitted_ok);
6878}

References DistanceVectorHop::pd, and update_performance_data().

Referenced by handle_acknowledged().

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

◆ completed_pending_message()

static void completed_pending_message ( struct PendingMessage pm)
static

We have completed transmission of pm, remove it from the transmission queues (and if it is a fragment, continue up the tree as necessary).

Parameters
pmpending message that was transmitted

Definition at line 6889 of file gnunet-service-transport.c.

6890{
6891 struct PendingMessage *pos;
6892
6894 "Complete transmission of message %" PRIu64 " %u\n",
6895 pm->logging_uuid,
6896 pm->pmt);
6897 switch (pm->pmt)
6898 {
6899 case PMT_CORE:
6901 /* Full message sent, we are done */
6903 return;
6904
6905 case PMT_FRAGMENT_BOX:
6906 /* Fragment sent over reliable channel */
6907 pos = pm->frag_parent;
6911 "pos frag_off %lu pos bytes_msg %lu pmt %u parent %u\n",
6912 (unsigned long) pos->frag_off,
6913 (unsigned long) pos->bytes_msg,
6914 pos->pmt,
6915 NULL == pos->frag_parent ? 1 : 0);
6916 /* check if subtree is done */
6917 while ((NULL == pos->head_frag) && (pos->frag_off == (pos->bytes_msg
6918 - sizeof(struct
6920 &&
6921 (NULL != pos->frag_parent))
6922 {
6923 pm = pos;
6924 pos = pm->frag_parent;
6925 if ((NULL == pos) && (PMT_DV_BOX == pm->pmt))
6926 {
6928 return;
6929 }
6930 else if (PMT_DV_BOX == pm->pmt)
6931 {
6933 return;
6934 }
6937 }
6938
6939 /* Was this the last applicable fragment? */
6940 if ((NULL == pos->head_frag) && (NULL == pos->frag_parent || PMT_DV_BOX ==
6941 pos->pmt) &&
6942 (pos->frag_off == pos->bytes_msg))
6944 return;
6945
6946 case PMT_DV_BOX:
6948 "Completed transmission of message %" PRIu64 " (DV Box)\n",
6949 pm->logging_uuid);
6950 if (NULL != pm->frag_parent)
6951 {
6952 pos = pm->frag_parent;
6954 pos->bpm = NULL;
6956 }
6957 else
6959 return;
6960 }
6961}
static void client_send_response(struct PendingMessage *pm)
Send a response to the pm that we have processed a "send" request.
struct PendingMessage * bpm
This message, reliability or DV-boxed.

References PendingMessage::bpm, PendingMessage::bytes_msg, client_send_response(), PendingMessage::frag_off, PendingMessage::frag_parent, free_pending_message(), GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, PendingMessage::head_frag, pm, PendingMessage::pmt, PMT_CORE, PMT_DV_BOX, PMT_FRAGMENT_BOX, PMT_RELIABILITY_BOX, and PendingMessage::tail_frag.

Referenced by handle_acknowledged(), and transmit_on_queue().

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

◆ handle_acknowledged()

static void handle_acknowledged ( struct PendingAcknowledgement pa,
struct GNUNET_TIME_Relative  ack_delay 
)
static

The pa was acknowledged, process the acknowledgement.

Parameters
pathe pending acknowledgement that was satisfied
ack_delayartificial delay from cumulative acks created by the other peer

Definition at line 6972 of file gnunet-service-transport.c.

6974{
6975 struct GNUNET_TIME_Relative delay;
6976
6978 delay = GNUNET_TIME_relative_subtract (delay, ack_delay);
6979 if (NULL != pa->queue && 1 == pa->num_send)
6981 if (NULL != pa->dvh && 1 == pa->num_send)
6982 update_dvh_performance (pa->dvh, delay, pa->message_size);
6983 if (NULL != pa->pm)
6986}
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.
static void free_pending_acknowledgement(struct PendingAcknowledgement *pa)
Release pa data structure.
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.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Subtract relative timestamp from the other.
Definition: time.c:605
struct GNUNET_TIME_Absolute transmission_time
Time of the transmission, for RTT calculation.
uint16_t message_size
Number of bytes of the original message (to calculate bandwidth).

References completed_pending_message(), PendingAcknowledgement::dvh, free_pending_acknowledgement(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_subtract(), PendingAcknowledgement::message_size, PendingAcknowledgement::num_send, PendingAcknowledgement::pm, PendingAcknowledgement::queue, PendingAcknowledgement::transmission_time, update_dvh_performance(), and update_queue_performance().

Referenced by handle_reliability_ack().

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

◆ check_reliability_ack()

static int check_reliability_ack ( void *  cls,
const struct TransportReliabilityAckMessage ra 
)
static

Communicator gave us a reliability ack.

Check it is well-formed.

Parameters
clsa struct CommunicatorMessageContext (unused)
rathe message that was received
Returns
#GNUNET_Ok if ra is well-formed

Definition at line 6997 of file gnunet-service-transport.c.

6999{
7000 unsigned int n_acks;
7001
7002 (void) cls;
7003 n_acks = (ntohs (ra->header.size) - sizeof(*ra))
7004 / sizeof(struct TransportCummulativeAckPayloadP);
7005 if (0 == n_acks)
7006 {
7007 GNUNET_break_op (0);
7008 return GNUNET_SYSERR;
7009 }
7010 if ((ntohs (ra->header.size) - sizeof(*ra)) !=
7011 n_acks * sizeof(struct TransportCummulativeAckPayloadP))
7012 {
7013 GNUNET_break_op (0);
7014 return GNUNET_SYSERR;
7015 }
7016 return GNUNET_OK;
7017}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, TransportReliabilityAckMessage::header, and GNUNET_MessageHeader::size.

◆ handle_reliability_ack()

static void handle_reliability_ack ( void *  cls,
const struct TransportReliabilityAckMessage ra 
)
static

Communicator gave us a reliability ack.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
rathe message that was received

Definition at line 7028 of file gnunet-service-transport.c.

7030{
7031 struct CommunicatorMessageContext *cmc = cls;
7032 const struct TransportCummulativeAckPayloadP *ack;
7033 unsigned int n_acks;
7034 uint32_t ack_counter;
7035
7036 n_acks = (ntohs (ra->header.size) - sizeof(*ra))
7037 / sizeof(struct TransportCummulativeAckPayloadP);
7038 ack = (const struct TransportCummulativeAckPayloadP *) &ra[1];
7039 for (unsigned int i = 0; i < n_acks; i++)
7040 {
7041 struct PendingAcknowledgement *pa =
7043 if (NULL == pa)
7044 {
7046 "Received ACK from %s with UUID %s which is unknown to us!\n",
7047 GNUNET_i2s (&cmc->im.sender),
7048 GNUNET_uuid2s (&ack[i].ack_uuid.value));
7050 GST_stats,
7051 "# FRAGMENT_ACKS dropped, no matching pending message",
7052 1,
7053 GNUNET_NO);
7054 continue;
7055 }
7057 "Received ACK from %s with UUID %s\n",
7058 GNUNET_i2s (&cmc->im.sender),
7059 GNUNET_uuid2s (&ack[i].ack_uuid.value));
7060 handle_acknowledged (pa, GNUNET_TIME_relative_ntoh (ack[i].ack_delay));
7061 }
7062
7063 ack_counter = htonl (ra->ack_counter);
7064 (void) ack_counter; /* silence compiler warning for now */
7065 // FIXME-OPTIMIZE: track ACK losses based on ack_counter somewhere!
7066 // (DV and/or Neighbour?)
7067 finish_cmc_handling (cmc);
7068}
static void handle_acknowledged(struct PendingAcknowledgement *pa, struct GNUNET_TIME_Relative ack_delay)
The pa was acknowledged, process the acknowledgement.
void * GNUNET_CONTAINER_multiuuidmap_get(const struct GNUNET_CONTAINER_MultiUuidmap *map, const struct GNUNET_Uuid *key)
Given a key find a value in the map matching the key.

References TransportReliabilityAckMessage::ack_counter, PendingAcknowledgement::ack_uuid, finish_cmc_handling(), GNUNET_CONTAINER_multiuuidmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_relative_ntoh(), GNUNET_uuid2s(), GST_stats, handle_acknowledged(), TransportReliabilityAckMessage::header, CommunicatorMessageContext::im, pending_acks, GNUNET_TRANSPORT_IncomingMessage::sender, GNUNET_MessageHeader::size, and AcknowledgementUUIDP::value.

Here is the call graph for this function:

◆ check_backchannel_encapsulation()

static int check_backchannel_encapsulation ( void *  cls,
const struct TransportBackchannelEncapsulationMessage be 
)
static

Communicator gave us a backchannel encapsulation.

Check the message.

Parameters
clsa struct CommunicatorMessageContext
bethe send message that was sent
Returns
GNUNET_YES if message is well-formed

Definition at line 7079 of file gnunet-service-transport.c.

7082{
7083 uint16_t size = ntohs (be->header.size) - sizeof(*be);
7084 const struct GNUNET_MessageHeader *inbox =
7085 (const struct GNUNET_MessageHeader *) &be[1];
7086 const char *is;
7087 uint16_t isize;
7088
7089 (void) cls;
7090 if (ntohs (inbox->size) >= size)
7091 {
7092 GNUNET_break_op (0);
7093 return GNUNET_SYSERR;
7094 }
7095 isize = ntohs (inbox->size);
7096 is = ((const char *) inbox) + isize;
7097 size -= isize;
7098 if ('\0' != is[size - 1])
7099 {
7100 GNUNET_break_op (0);
7101 return GNUNET_SYSERR;
7102 }
7103 return GNUNET_YES;
7104}

References GNUNET_break_op, GNUNET_SYSERR, GNUNET_YES, TransportBackchannelEncapsulationMessage::header, is, GNUNET_MessageHeader::size, and size.

◆ handle_backchannel_encapsulation()

static void handle_backchannel_encapsulation ( void *  cls,
const struct TransportBackchannelEncapsulationMessage be 
)
static

Communicator gave us a backchannel encapsulation.

Process the request. (We are the destination of the backchannel here.)

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
bethe message that was received

Definition at line 7116 of file gnunet-service-transport.c.

7119{
7120 struct CommunicatorMessageContext *cmc = cls;
7122 struct GNUNET_MQ_Envelope *env;
7123 struct TransportClient *tc;
7124 const struct GNUNET_MessageHeader *inbox =
7125 (const struct GNUNET_MessageHeader *) &be[1];
7126 uint16_t isize = ntohs (inbox->size);
7127 const char *target_communicator = ((const char *) inbox) + isize;
7128 char *sender;
7129 char *self;
7130
7131 GNUNET_asprintf (&sender,
7132 "%s",
7133 GNUNET_i2s (&cmc->im.sender));
7134 GNUNET_asprintf (&self,
7135 "%s",
7137
7138 /* Find client providing this communicator */
7139 for (tc = clients_head; NULL != tc; tc = tc->next)
7140 if ((CT_COMMUNICATOR == tc->type) &&
7141 (0 ==
7142 strcmp (tc->details.communicator.address_prefix, target_communicator)))
7143 break;
7144 if (NULL == tc)
7145 {
7146 char *stastr;
7147
7149 &stastr,
7150 "# Backchannel message dropped: target communicator `%s' unknown",
7151 target_communicator);
7153 GNUNET_free (stastr);
7154 finish_cmc_handling (cmc);
7155 return;
7156 }
7157 /* Finally, deliver backchannel message to communicator */
7159 "Delivering backchannel message from %s to %s of type %u to %s\n",
7160 sender,
7161 self,
7162 ntohs (inbox->type),
7163 target_communicator);
7165 cbi,
7166 isize,
7168 cbi->pid = cmc->im.sender;
7169 memcpy (&cbi[1], inbox, isize);
7170 GNUNET_MQ_send (tc->mq, env);
7171 finish_cmc_handling (cmc);
7172}
#define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING
Transport signalling incoming backchannel message to a communicator.
Message from transport to communicator passing along a backchannel message from the given peer pid.
Definition: transport.h:655
struct GNUNET_PeerIdentity pid
Origin peer.
Definition: transport.h:670

References clients_head, CT_COMMUNICATOR, env, finish_cmc_handling(), GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GST_my_identity, GST_stats, CommunicatorMessageContext::im, GNUNET_TRANSPORT_CommunicatorBackchannelIncoming::pid, GNUNET_TRANSPORT_IncomingMessage::sender, GNUNET_MessageHeader::size, tc, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ path_cleanup_cb()

static void path_cleanup_cb ( void *  cls)
static

Task called when we should check if any of the DV paths we have learned to a target are due for garbage collection.

Collects stale paths, and possibly frees the entire DV entry if no paths are left. Otherwise re-schedules itself.

Parameters
clsa struct DistanceVector

Definition at line 7185 of file gnunet-service-transport.c.

7186{
7187 struct DistanceVector *dv = cls;
7188 struct DistanceVectorHop *pos;
7189
7190 dv->timeout_task = NULL;
7191 while (NULL != (pos = dv->dv_head))
7192 {
7193 GNUNET_assert (dv == pos->dv);
7195 break;
7197 }
7198 if (NULL == pos)
7199 {
7200 free_dv_route (dv);
7201 return;
7202 }
7203 dv->timeout_task =
7205}
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 garba...
struct GNUNET_TIME_Absolute timeout
At what time do we forget about this path unless we see it again while learning?

References DistanceVectorHop::dv, DistanceVector::dv_head, free_distance_vector_hop(), free_dv_route(), GNUNET_assert, GNUNET_SCHEDULER_add_at(), GNUNET_TIME_absolute_get_remaining(), path_cleanup_cb(), GNUNET_TIME_Relative::rel_value_us, DistanceVectorHop::timeout, and DistanceVector::timeout_task.

Referenced by learn_dv_path(), and path_cleanup_cb().

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

◆ send_msg_from_cache()

static void send_msg_from_cache ( struct VirtualLink vl)
static

Definition at line 7209 of file gnunet-service-transport.c.

7210{
7211
7212 const struct GNUNET_PeerIdentity target = vl->target;
7213
7214
7216 {
7217 struct RingBufferEntry *ring_buffer_copy[RING_BUFFER_SIZE];
7218 unsigned int tail = GNUNET_YES == is_ring_buffer_full ? ring_buffer_head :
7219 0;
7220 unsigned int head = GNUNET_YES == is_ring_buffer_full ? RING_BUFFER_SIZE :
7223 struct CommunicatorMessageContext *cmc;
7224 struct RingBufferEntry *rbe;
7225 struct GNUNET_MessageHeader *mh;
7226
7228 "Sending from ring buffer, which has %u items\n",
7229 head);
7230
7231 ring_buffer_head = 0;
7232 for (unsigned int i = 0; i < head; i++)
7233 {
7234 rbe = ring_buffer[(i + tail) % RING_BUFFER_SIZE];
7235 cmc = rbe->cmc;
7236 mh = rbe->mh;
7237
7238 im = cmc->im;
7239 // mh = cmc->mh;
7241 "Sending message of type %u to ring buffer target %s using vl target %s index %u\n",
7242 mh->type,
7243 GNUNET_i2s (&im.sender),
7244 GNUNET_i2s2 (&target),
7245 (i + tail) % RING_BUFFER_SIZE);
7246 if (0 == GNUNET_memcmp (&target, &im.sender))
7247 {
7249 "Finish handling message of type %u and size %u\n",
7250 (unsigned int) ntohs (mh->type),
7251 (unsigned int) ntohs (mh->size));
7253 GNUNET_free (mh);
7254 GNUNET_free (rbe->cmc);
7255 GNUNET_free (rbe);
7256 }
7257 else
7258 {
7259 ring_buffer_copy[ring_buffer_head] = rbe;
7261 }
7262 }
7263
7266 {
7268 }
7269
7270 for (unsigned int i = 0; i < ring_buffer_head; i++)
7271 {
7272 ring_buffer[i] = ring_buffer_copy[i];
7274 "ring_buffer_copy[i]->mh->type for i %u %u\n",
7275 i,
7276 ring_buffer_copy[i]->mh->type);
7278 "ring_buffer[i]->mh->type for i %u %u\n",
7279 i,
7280 ring_buffer[i]->mh->type);
7281 }
7282
7284 "%u items still in ring buffer\n",
7286 }
7287
7289 {
7290 struct PendingMessage *ring_buffer_dv_copy[RING_BUFFER_SIZE];
7291 struct PendingMessage *pm;
7292 unsigned int tail = GNUNET_YES == is_ring_buffer_dv_full ?
7294 0;
7295 unsigned int head = GNUNET_YES == is_ring_buffer_dv_full ?
7298
7300 "Sending from ring buffer dv, which has %u items\n",
7301 head);
7302
7304 for (unsigned int i = 0; i < head; i++)
7305 {
7306 pm = ring_buffer_dv[(i + tail) % RING_BUFFER_SIZE];
7307
7309 "Sending to ring buffer target %s using vl target %s\n",
7310 GNUNET_i2s (&pm->target),
7311 GNUNET_i2s2 (&target));
7312 if (0 == GNUNET_memcmp (&target, &pm->target))
7313 {
7315 "Adding PendingMessage to vl, checking transmission.\n");
7316 pm->vl = vl;
7320 pm);
7321
7323 }
7324 else
7325 {
7326 ring_buffer_dv_copy[ring_buffer_dv_head] = pm;
7328 }
7329 }
7330
7332 {
7334 }
7335
7336 for (unsigned int i = 0; i < ring_buffer_dv_head; i++)
7337 ring_buffer_dv[i] = ring_buffer_dv_copy[i];
7338
7340 "%u items still in ring buffer dv.\n",
7342
7343 }
7344}
static unsigned int ring_buffer_dv_head
Head of the ring buffer.
static struct PendingMessage * ring_buffer_dv[RING_BUFFER_SIZE]
Ring buffer for a forwarded DVBox message we did not deliver to the next hop, because of missing virt...
static unsigned int is_ring_buffer_dv_full
Is the ring buffer filled up to RING_BUFFER_SIZE.
const char * GNUNET_i2s2(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Inform transport about an incoming message.
Definition: transport.h:333
struct VirtualLink * vl
Target of the request (always the ultimate destination!).
struct GNUNET_PeerIdentity target
In case of a not validated neighbour, we store the target peer.

References check_vl_transmission(), RingBufferEntry::cmc, finish_handling_raw_message(), GNUNET_CONTAINER_MDLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_i2s2(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_YES, is_ring_buffer_dv_full, is_ring_buffer_full, mh, RingBufferEntry::mh, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, pm, ring_buffer, ring_buffer_dv, ring_buffer_dv_head, ring_buffer_head, RING_BUFFER_SIZE, GNUNET_TRANSPORT_IncomingMessage::sender, VirtualLink::target, PendingMessage::target, and PendingMessage::vl.

Referenced by activate_core_visible_dv_path(), and handle_validation_response().

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

◆ activate_core_visible_dv_path()

static void activate_core_visible_dv_path ( struct DistanceVectorHop hop)
static

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.

Parameters
hopa path to some peer that is the reason for activation

Definition at line 7355 of file gnunet-service-transport.c.

7356{
7357 struct DistanceVector *dv = hop->dv;
7358 struct VirtualLink *vl;
7359
7360 vl = lookup_virtual_link (&dv->target);
7361 if (NULL == vl)
7362 {
7363
7364 vl = GNUNET_new (struct VirtualLink);
7366 "Creating new virtual link %p to %s using DV!\n",
7367 vl,
7368 GNUNET_i2s (&dv->target));
7369 vl->burst_addr = NULL;
7370 vl->confirmed = GNUNET_YES;
7371 vl->message_uuid_ctr =
7373 vl->target = dv->target;
7379 links,
7380 &vl->target,
7381 vl,
7383 vl->dv = dv;
7384 dv->vl = vl;
7385 vl->visibility_task =
7388 /* We lacked a confirmed connection to the target
7389 before, so tell CORE about it (finally!) */
7392 }
7393 else
7394 {
7395 /* Link was already up, remember dv is also now available and we are done */
7396 vl->dv = dv;
7397 dv->vl = vl;
7398 if (GNUNET_NO == vl->confirmed)
7399 {
7400 vl->confirmed = GNUNET_YES;
7401 vl->visibility_task =
7404 /* We lacked a confirmed connection to the target
7405 before, so tell CORE about it (finally!) */
7408 }
7409 else
7411 "Virtual link to %s could now also use DV!\n",
7412 GNUNET_i2s (&dv->target));
7413 }
7414}
static void cores_send_connect_info(const struct GNUNET_PeerIdentity *pid)
Send message to CORE clients that we gained a connection.
#define RECV_WINDOW_SIZE
Window size.
static void send_msg_from_cache(struct VirtualLink *vl)
#define DEFAULT_WINDOW_SIZE
How big is the flow control window size by default; limits per-neighbour RAM utilization.
struct GNUNET_TIME_Absolute path_valid_until
For how long is the validation of this path considered valid? Set to ZERO if the path is learned by s...

References VirtualLink::available_fc_window_size, VirtualLink::burst_addr, check_link_down(), VirtualLink::confirmed, consider_sending_fc(), VirtualLink::core_recv_window, cores_send_connect_info(), DEFAULT_WINDOW_SIZE, VirtualLink::dv, DistanceVectorHop::dv, GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_at(), GNUNET_YES, VirtualLink::incoming_fc_window_size, links, lookup_virtual_link(), VirtualLink::message_uuid_ctr, DistanceVectorHop::path_valid_until, RECV_WINDOW_SIZE, send_msg_from_cache(), VirtualLink::target, DistanceVector::target, VirtualLink::visibility_task, and DistanceVector::vl.

Referenced by learn_dv_path().

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

◆ learn_dv_path()

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 
)
static

We have learned a path through the network to some other peer, add it to our DV data structure (returning GNUNET_YES on success).

We do not add paths if we have a sufficient number of shorter paths to this target already (returning GNUNET_NO).

We also do not add problematic paths, like those where we lack the first hop in our neighbour list (i.e. due to a topology change) or where some non-first hop is in our neighbour list (returning GNUNET_SYSERR).

Parameters
paththe path we learned, path[0] should be us, and then path contains a valid path from us to path[path_len-1] path[1] should be a direct neighbour (we should check!)
path_lennumber of entries on the path, at least three!
network_latencyhow long does the message take from us to path[path_len-1]? set to "forever" if unknown
path_valid_untilhow long is this path considered validated? Maybe be zero.
Returns
GNUNET_YES on success, GNUNET_NO if we have better path(s) to the target GNUNET_SYSERR if the path is useless and/or invalid (i.e. path[1] not a direct neighbour or path[i+1] is a direct neighbour for i>0)

Definition at line 7443 of file gnunet-service-transport.c.

7447{
7448 struct DistanceVectorHop *hop;
7449 struct DistanceVector *dv;
7450 struct Neighbour *next_hop;
7451 unsigned int shorter_distance;
7452
7453 if (path_len < 3)
7454 {
7455 /* what a boring path! not allowed! */
7456 GNUNET_break (0);
7457 return GNUNET_SYSERR;
7458 }
7459 GNUNET_assert (0 == GNUNET_memcmp (&GST_my_identity, &path[0]));
7460 next_hop = lookup_neighbour (&path[1]);
7461 if (NULL == next_hop)
7462 {
7463 /* next hop must be a neighbour, otherwise this whole thing is useless! */
7464 GNUNET_break (0);
7465 return GNUNET_SYSERR;
7466 }
7467 for (unsigned int i = 2; i < path_len; i++)
7468 {
7469 struct Neighbour *n = lookup_neighbour (&path[i]);
7470 struct GNUNET_TIME_Absolute q_timeout;
7471
7472 if (NULL != n)
7473 {
7474 q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
7475 for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
7476 q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
7478 "remaining %lu to %s\n",
7479 (unsigned long) GNUNET_TIME_absolute_get_remaining (q_timeout)
7480 .rel_value_us,
7481 GNUNET_i2s (&n->pid));
7482 if (0 != GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
7483 {
7484 /* Useless path: we have a direct active connection to some hop
7485 in the middle of the path, so this one is not even
7486 terribly useful for redundancy */
7488 "Path of %u hops useless: directly link to hop %u (%s)\n",
7489 path_len,
7490 i,
7491 GNUNET_i2s (&path[i]));
7493 "# Useless DV path ignored: hop is neighbour",
7494 1,
7495 GNUNET_NO);
7496 return GNUNET_SYSERR;
7497 }
7498 }
7499 }
7500 dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &path[path_len - 1]);
7501 if (NULL == dv)
7502 {
7503 dv = GNUNET_new (struct DistanceVector);
7504 dv->target = path[path_len - 1];
7507 dv);
7510 dv_routes,
7511 &dv->target,
7512 dv,
7514 }
7515 /* Check if we have this path already! */
7516 shorter_distance = 0;
7517 for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
7518 pos = pos->next_dv)
7519 {
7520 if (pos->distance < path_len - 3)
7521 shorter_distance++;
7522 /* Note that the distances in 'pos' excludes us (path[0]),
7523 the next_hop (path[1]) and the target so we need to subtract three
7524 and check next_hop explicitly */
7525 if ((pos->distance == path_len - 3) && (pos->next_hop == next_hop))
7526 {
7527 int match = GNUNET_YES;
7528
7529 for (unsigned int i = 0; i < pos->distance; i++)
7530 {
7531 if (0 != GNUNET_memcmp (&pos->path[i], &path[i + 2]))
7532 {
7533 match = GNUNET_NO;
7534 break;
7535 }
7536 }
7537 if (GNUNET_YES == match)
7538 {
7539 struct GNUNET_TIME_Relative last_timeout;
7540
7541 /* Re-discovered known path, update timeout */
7543 "# Known DV path refreshed",
7544 1,
7545 GNUNET_NO);
7546 last_timeout = GNUNET_TIME_absolute_get_remaining (pos->timeout);
7547 pos->timeout =
7549 pos->path_valid_until =
7550 GNUNET_TIME_absolute_max (pos->path_valid_until, path_valid_until);
7551 GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, pos);
7552 GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, pos);
7553 if (0 <
7556 if (last_timeout.rel_value_us <
7559 .rel_value_us)
7560 {
7561 /* Some peer send DV learn messages too often, we are learning
7562 the same path faster than it would be useful; do not forward! */
7564 "Rediscovered path too quickly, not forwarding further\n")
7565 ;
7566 return GNUNET_NO;
7567 }
7569 "Refreshed known path to %s valid until %s, forwarding further\n",
7570 GNUNET_i2s (&dv->target),
7572 pos->path_valid_until));
7573 return GNUNET_YES;
7574 }
7575 }
7576 }
7577 /* Count how many shorter paths we have (incl. direct
7578 neighbours) before simply giving up on this one! */
7579 if (shorter_distance >= MAX_DV_PATHS_TO_TARGET)
7580 {
7581 /* We have a shorter path already! */
7583 "Have many shorter DV paths %s, not forwarding further\n",
7584 GNUNET_i2s (&dv->target));
7585 return GNUNET_NO;
7586 }
7587 /* create new DV path entry */
7589 "Discovered new DV path to %s valid until %s\n",
7590 GNUNET_i2s (&dv->target),
7591 GNUNET_STRINGS_absolute_time_to_string (path_valid_until));
7592 hop = GNUNET_malloc (sizeof(struct DistanceVectorHop)
7593 + sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
7594 hop->next_hop = next_hop;
7595 hop->dv = dv;
7596 hop->path = (const struct GNUNET_PeerIdentity *) &hop[1];
7597 memcpy (&hop[1],
7598 &path[2],
7599 sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
7601 hop->path_valid_until = path_valid_until;
7602 hop->distance = path_len - 3;
7603 hop->pd.aged_rtt = network_latency;
7604 GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, hop);
7606 next_hop->dv_head,
7607 next_hop->dv_tail,
7608 hop);
7609 if (0 < GNUNET_TIME_absolute_get_remaining (path_valid_until).rel_value_us)
7611 return GNUNET_YES;
7612}
#define DV_PATH_DISCOVERY_FREQUENCY
How long before paths expire would we like to (re)discover DV paths? Should be below DV_PATH_VALIDITY...
#define MAX_DV_PATHS_TO_TARGET
Maximum number of DV paths we keep simultaneously to the same target.
#define DV_PATH_VALIDITY_TIMEOUT
How long do we consider a DV path valid if we see no further updates on it? Note: the value chosen he...
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 sche...

References activate_core_visible_dv_path(), PerformanceData::aged_rtt, DistanceVectorHop::distance, DistanceVectorHop::dv, DistanceVector::dv_head, Neighbour::dv_head, DV_PATH_DISCOVERY_FREQUENCY, DV_PATH_VALIDITY_TIMEOUT, dv_routes, DistanceVector::dv_tail, Neighbour::dv_tail, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_MDLL_insert, GNUNET_CONTAINER_MDLL_remove, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcmp, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_max(), GNUNET_TIME_relative_subtract(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, GST_my_identity, GST_stats, lookup_neighbour(), MAX_DV_PATHS_TO_TARGET, DistanceVectorHop::next_dv, DistanceVectorHop::next_hop, DistanceVectorHop::path, path_cleanup_cb(), DistanceVectorHop::path_valid_until, DistanceVectorHop::pd, Neighbour::pid, q, Neighbour::queue_head, GNUNET_TIME_Relative::rel_value_us, DistanceVector::target, DistanceVectorHop::timeout, and DistanceVector::timeout_task.

Referenced by handle_dv_learn().

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

◆ check_dv_learn()

static int check_dv_learn ( void *  cls,
const struct TransportDVLearnMessage dvl 
)
static

Communicator gave us a DV learn message.

Check the message.

Parameters
clsa struct CommunicatorMessageContext
dvlthe send message that was sent
Returns
GNUNET_YES if message is well-formed

Definition at line 7623 of file gnunet-service-transport.c.

7624{
7625 uint16_t size = ntohs (dvl->header.size);
7626 uint16_t num_hops = ntohs (dvl->num_hops);
7627 const struct DVPathEntryP *hops = (const struct DVPathEntryP *) &dvl[1];
7628
7629 (void) cls;
7630 if (size != sizeof(*dvl) + num_hops * sizeof(struct DVPathEntryP))
7631 {
7632 GNUNET_break_op (0);
7633 return GNUNET_SYSERR;
7634 }
7635 if (num_hops > MAX_DV_HOPS_ALLOWED)
7636 {
7637 GNUNET_break_op (0);
7638 return GNUNET_SYSERR;
7639 }
7640 for (unsigned int i = 0; i < num_hops; i++)
7641 {
7642 if (0 == GNUNET_memcmp (&dvl->initiator, &hops[i].hop))
7643 {
7644 GNUNET_break_op (0);
7645 return GNUNET_SYSERR;
7646 }
7647 if (0 == GNUNET_memcmp (&GST_my_identity, &hops[i].hop))
7648 {
7649 GNUNET_break_op (0);
7650 return GNUNET_SYSERR;
7651 }
7652 }
7653 return GNUNET_YES;
7654}
An entry describing a peer on a path in a struct TransportDVLearnMessage message.
struct GNUNET_PeerIdentity initiator
Identity of the peer that started this learning activity.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN.
uint16_t num_hops
Number of hops this messages has travelled, in NBO.

References GNUNET_break_op, GNUNET_memcmp, GNUNET_SYSERR, GNUNET_YES, GST_my_identity, TransportDVLearnMessage::header, DVPathEntryP::hop, TransportDVLearnMessage::initiator, MAX_DV_HOPS_ALLOWED, TransportDVLearnMessage::num_hops, GNUNET_MessageHeader::size, and size.

◆ forward_dv_learn()

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 
)
static

Build and forward a DV learn message to next_hop.

Parameters
next_hoppeer to send the message to
msgmessage received
bi_historybitmask specifying hops on path that were bidirectional
nhopslength of the hops array
hopspath the message traversed so far
in_timewhen did we receive the message, used to calculate network delay

Definition at line 7669 of file gnunet-service-transport.c.

7675{
7676 struct Neighbour *n;
7677 struct VirtualLink *vl;
7678 struct DVPathEntryP *dhops;
7679 char buf[sizeof(struct TransportDVLearnMessage)
7680 + (nhops + 1) * sizeof(struct DVPathEntryP)] GNUNET_ALIGN;
7681 struct TransportDVLearnMessage *fwd = (struct TransportDVLearnMessage *) buf;
7682 struct GNUNET_TIME_Relative nnd;
7683
7684 /* compute message for forwarding */
7686 "Forwarding DV learn message originating from %s to %s\n",
7687 GNUNET_i2s (&msg->initiator),
7688 GNUNET_i2s2 (next_hop));
7691 fwd->header.size = htons (sizeof(struct TransportDVLearnMessage)
7692 + (nhops + 1) * sizeof(struct DVPathEntryP));
7693 fwd->num_hops = htons (nhops + 1);
7694 fwd->bidirectional = htons (bi_history);
7697 msg->non_network_delay));
7699 fwd->init_sig = msg->init_sig;
7700 fwd->initiator = msg->initiator;
7701 fwd->challenge = msg->challenge;
7702 fwd->monotonic_time = msg->monotonic_time;
7703 dhops = (struct DVPathEntryP *) &fwd[1];
7704 GNUNET_memcpy (dhops, hops, sizeof(struct DVPathEntryP) * nhops);
7705 dhops[nhops].hop = GST_my_identity;
7706 {
7707 struct DvHopPS dhp = {
7709 .purpose.size = htonl (sizeof(dhp)),
7710 .pred = (0 == nhops) ? msg->initiator : dhops[nhops - 1].hop,
7711 .succ = *next_hop,
7712 .challenge = msg->challenge
7713 };
7715 &dhp,
7716 &dhops[nhops].hop_sig);
7717 }
7718 /*route_control_message_without_fc (next_hop,
7719 &fwd->header,
7720 RMO_UNCONFIRMED_ALLOWED);*/
7721 vl = lookup_virtual_link (next_hop);
7722 if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
7723 {
7725 &fwd->header,
7727 }
7728 else
7729 {
7730 /* Use route via neighbour */
7731 n = lookup_neighbour (next_hop);
7732 if (NULL != n)
7734 n,
7735 &fwd->header,
7737 }
7738}
#define GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP
Signature by a peer affirming that it is on a DV path.
struct GNUNET_PeerIdentity hop
Identity of a peer on the path.
Content signed by each peer during DV learning.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose is GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP.
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used by the initiator to re-identify the path.
struct GNUNET_TIME_RelativeNBO non_network_delay
Peers receiving this message and delaying forwarding to other peers for any reason should increment t...
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Time at the initiator when generating the signature.
struct GNUNET_CRYPTO_EddsaSignature init_sig
Signature of this hop over the path, of purpose GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR.
uint16_t bidirectional
Bitmask of the last 16 hops indicating whether they are confirmed available (without DV) in both dire...

References TransportDVLearnMessage::bidirectional, TransportDVLearnMessage::challenge, VirtualLink::confirmed, GNUNET_ALIGN, GNUNET_assert, GNUNET_CRYPTO_eddsa_sign, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_i2s2(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_ntoh(), GNUNET_YES, GST_my_identity, GST_my_private_key, TransportDVLearnMessage::header, DVPathEntryP::hop, TransportDVLearnMessage::init_sig, TransportDVLearnMessage::initiator, lookup_neighbour(), lookup_virtual_link(), MAX_DV_HOPS_ALLOWED, TransportDVLearnMessage::monotonic_time, msg, TransportDVLearnMessage::non_network_delay, TransportDVLearnMessage::num_hops, GNUNET_CRYPTO_EccSignaturePurpose::purpose, DvHopPS::purpose, RMO_UNCONFIRMED_ALLOWED, route_control_message_without_fc(), route_via_neighbour(), GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by dv_neighbour_transmission(), and handle_dv_learn().

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

◆ validate_dv_initiator_signature()

static int validate_dv_initiator_signature ( struct GNUNET_TIME_AbsoluteNBO  sender_monotonic_time,
const struct GNUNET_PeerIdentity init,
const struct GNUNET_CRYPTO_ChallengeNonceP challenge,
const struct GNUNET_CRYPTO_EddsaSignature init_sig 
)
static

Check signature of type GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR.

Parameters
sender_monotonic_timemonotonic time of the initiator
initthe signer
challengethe challenge that was signed
init_sigsignature presumably by init
Returns
GNUNET_OK if the signature is valid

Definition at line 7751 of file gnunet-service-transport.c.

7756{
7757 struct DvInitPS ip = { .purpose.purpose = htonl (
7759 .purpose.size = htonl (sizeof(ip)),
7760 .monotonic_time = sender_monotonic_time,
7761 .challenge = *challenge };
7762
7763 if (
7764 GNUNET_OK !=
7766 &ip,
7767 init_sig,
7768 &init->public_key))
7769 {
7770 GNUNET_break_op (0);
7771 return GNUNET_SYSERR;
7772 }
7773 return GNUNET_OK;
7774}
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:73
#define GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR
Signature by a peer affirming that it originated the DV path.
#define GNUNET_CRYPTO_eddsa_verify(purp, ps, sig, pub)
Verify EdDSA signature.
Content signed by the initiator during DV learning.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose is GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR.
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used by the initiator to re-identify the path.

References DvInitPS::challenge, GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR, GNUNET_SYSERR, init, GNUNET_CRYPTO_EccSignaturePurpose::purpose, and DvInitPS::purpose.

Referenced by handle_dv_learn().

Here is the caller graph for this function:

◆ dv_neighbour_selection()

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

Function called for each neighbour during handle_dv_learn.

Parameters
clsa struct NeighbourSelectionContext *
pididentity of the peer
valuea struct Neighbour
Returns
GNUNET_YES (always)

Definition at line 7833 of file gnunet-service-transport.c.

7836{
7837 struct NeighbourSelectionContext *nsc = cls;
7838
7839 (void) value;
7840 if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
7841 return GNUNET_YES; /* skip initiator */
7842 for (unsigned int i = 0; i < nsc->nhops; i++)
7843 if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
7844 return GNUNET_YES;
7845 /* skip peers on path */
7846 nsc->num_eligible++;
7847 return GNUNET_YES;
7848}
Closure for dv_neighbour_selection and dv_neighbour_transmission.
const struct TransportDVLearnMessage * dvl
Original message we received.
const struct DVPathEntryP * hops
The hops taken.
unsigned int num_eligible
Number of peers eligible for selection.
uint16_t nhops
Number of hops in hops.

References NeighbourSelectionContext::dvl, GNUNET_memcmp, GNUNET_YES, DVPathEntryP::hop, NeighbourSelectionContext::hops, TransportDVLearnMessage::initiator, NeighbourSelectionContext::nhops, NeighbourSelectionContext::num_eligible, pid, and value.

Referenced by handle_dv_learn().

Here is the caller graph for this function:

◆ dv_neighbour_transmission()

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

Function called for each neighbour during handle_dv_learn.

We call forward_dv_learn() on the neighbour(s) selected during dv_neighbour_selection().

Parameters
clsa struct NeighbourSelectionContext *
pididentity of the peer
valuea struct Neighbour
Returns
GNUNET_YES (always)

Definition at line 7862 of file gnunet-service-transport.c.

7865{
7866 struct NeighbourSelectionContext *nsc = cls;
7867
7869 "transmission %s\n",
7870 GNUNET_i2s (pid));
7871 (void) value;
7872 if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
7873 return GNUNET_YES; /* skip initiator */
7874 for (unsigned int i = 0; i < nsc->nhops; i++)
7875 if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
7876 return GNUNET_YES;
7877 /* skip peers on path */
7878 for (unsigned int i = 0; i < nsc->num_selections; i++)
7879 {
7880 if (nsc->selections[i] == nsc->num_eligible)
7881 {
7883 nsc->dvl,
7884 nsc->bi_history,
7885 nsc->nhops,
7886 nsc->hops,
7887 nsc->in_time);
7888 break;
7889 }
7890 }
7891 nsc->num_eligible++;
7892 return GNUNET_YES;
7893}
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.
struct GNUNET_TIME_Absolute in_time
Time we received the message.
uint16_t bi_history
Bitmap of bidirectional connections encountered.
unsigned int num_selections
Number of peers that were selected for forwarding.
uint32_t selections[MAX_DV_DISCOVERY_SELECTION]
Offsets of the selected peers.

References NeighbourSelectionContext::bi_history, NeighbourSelectionContext::dvl, forward_dv_learn(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_YES, DVPathEntryP::hop, NeighbourSelectionContext::hops, NeighbourSelectionContext::in_time, TransportDVLearnMessage::initiator, NeighbourSelectionContext::nhops, NeighbourSelectionContext::num_eligible, NeighbourSelectionContext::num_selections, pid, NeighbourSelectionContext::selections, and value.

Referenced by handle_dv_learn().

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

◆ calculate_fork_degree()

static unsigned int calculate_fork_degree ( unsigned int  hops_taken,
unsigned int  neighbour_count,
unsigned int  eligible_count 
)
static

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.

NOTE: technically we might want to include NSE in the formula to get a better grip on the overall network size. However, for now using NSE here would create a dependency issue in the build system. => Left for later, hardcoded to 50 for now.

The goal of the formula is that we want to reach a total of LOG(NSE) peers via DV (target_total). We want the reach to be spread out over various distances to the origin, with a bias towards shorter distances.

We make the strong assumption that the network topology looks "similar" at other hops, in particular the neighbour_count should be comparable at other hops.

If the local neighbourhood is densely connected, we expect that eligible_count is close to neighbour_count minus hops_taken as a lot of the path is already known. In that case, we should forward to few(er) peers to try to find a path out of the neighbourhood. OTOH, if eligible_count is close to neighbour_count, we should forward to many peers as we are either still close to the origin (i.e. hops_taken is small) or because we managed to get beyond a local cluster. We express this as the boost_factor using the square of the fraction of eligible neighbours (so if only 50% are eligible, we boost by 1/4, but if 99% are eligible, the 'boost' will be almost 1).

Second, the more hops we have taken, the larger the problem of an exponential traffic explosion gets. So we take the target_total, and compute our degree such that at each distance d 2^{-d} peers are selected (corrected by the boost_factor).

Parameters
hops_takennumber of hops DVInit has travelled so far
neighbour_countnumber of neighbours we have in total
eligible_countnumber of neighbours we could in theory forward to

Definition at line 7940 of file gnunet-service-transport.c.

7943{
7944 double target_total = 50.0; /* FIXME: use LOG(NSE)? */
7945 double eligible_ratio =
7946 ((double) eligible_count) / ((double) neighbour_count);
7947 double boost_factor = eligible_ratio * eligible_ratio;
7948 unsigned int rnd;
7949 double left;
7950
7951 if (hops_taken >= 64)
7952 {
7953 GNUNET_break (0);
7954 return 0; /* precaution given bitshift below */
7955 }
7956 for (unsigned int i = 1; i < hops_taken; i++)
7957 {
7958 /* For each hop, subtract the expected number of targets
7959 reached at distance d (so what remains divided by 2^d) */
7960 target_total -= (target_total * boost_factor / (1LLU << i));
7961 }
7962 rnd =
7963 (unsigned int) floor (target_total * boost_factor / (1LLU << hops_taken));
7964 /* round up or down probabilistically depending on how close we were
7965 when floor()ing to rnd */
7966 left = target_total - (double) rnd;
7967 if (UINT32_MAX * left >
7969 rnd++; /* round up */
7971 "Forwarding DV learn message of %u hops %u(/%u/%u) times\n",
7972 hops_taken,
7973 rnd,
7974 eligible_count,
7975 neighbour_count);
7976 return rnd;
7977}

References GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and consensus-simulation::int.

Referenced by handle_dv_learn().

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

◆ neighbour_store_dvmono_cb()

static void neighbour_store_dvmono_cb ( void *  cls,
int  success 
)
static

Function called when peerstore is done storing a DV monotonic time.

Parameters
clsa struct Neighbour
successGNUNET_YES if peerstore was successful

Definition at line 7987 of file gnunet-service-transport.c.

7988{
7989 struct Neighbour *n = cls;
7990
7991 n->sc = NULL;
7992 if (GNUNET_YES != success)
7994 "Failed to store other peer's monotonic time in peerstore!\n");
7995}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_YES, and Neighbour::sc.

Referenced by handle_dv_learn().

Here is the caller graph for this function:

◆ get_network_latency()

static struct GNUNET_TIME_Relative get_network_latency ( const struct TransportDVLearnMessage dvl)
static

Definition at line 7999 of file gnunet-service-transport.c.

8000{
8001 struct GNUNET_TIME_Relative host_latency_sum;
8002 struct GNUNET_TIME_Relative latency;
8003 struct GNUNET_TIME_Relative network_latency;
8004 uint16_t nhops = ntohs (dvl->num_hops);;
8005
8006 /* We initiated this, learn the forward path! */
8007 host_latency_sum = GNUNET_TIME_relative_ntoh (dvl->non_network_delay);
8008
8009 // Need also something to lookup initiation time
8010 // to compute RTT! -> add RTT argument here?
8012 dvl->monotonic_time));
8013 GNUNET_assert (latency.rel_value_us >= host_latency_sum.rel_value_us);
8014 // latency = GNUNET_TIME_UNIT_FOREVER_REL; // FIXME: initialize properly
8015 // (based on dvl->challenge, we can identify time of origin!)
8016
8017 network_latency = GNUNET_TIME_relative_subtract (latency, host_latency_sum);
8018 /* assumption: latency on all links is the same */
8019 network_latency = GNUNET_TIME_relative_divide (network_latency, nhops);
8020
8021 return network_latency;
8022}
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:741

References GNUNET_assert, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_ntoh(), GNUNET_TIME_relative_subtract(), and GNUNET_TIME_Relative::rel_value_us.

Referenced by handle_dv_learn().

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

◆ handle_dv_learn()

static void handle_dv_learn ( void *  cls,
const struct TransportDVLearnMessage dvl 
)
static

Communicator gave us a DV learn message.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
dvlthe message that was received

Definition at line 8033 of file gnunet-service-transport.c.

8034{
8035 struct CommunicatorMessageContext *cmc = cls;
8037 int bi_hop;
8038 uint16_t nhops;
8039 uint16_t bi_history;
8040 const struct DVPathEntryP *hops;
8041 int do_fwd;
8042 int did_initiator;
8043 struct GNUNET_TIME_Absolute in_time;
8044 struct Neighbour *n;
8045
8046 nhops = ntohs (dvl->num_hops); /* 0 = sender is initiator */
8047 bi_history = ntohs (dvl->bidirectional);
8048 hops = (const struct DVPathEntryP *) &dvl[1];
8049 if (0 == nhops)
8050 {
8051 /* sanity check */
8052 if (0 != GNUNET_memcmp (&dvl->initiator, &cmc->im.sender))
8053 {
8054 GNUNET_break (0);
8055 finish_cmc_handling (cmc);
8056 return;
8057 }
8058 }
8059 else
8060 {
8062 "handle dv learn message last hop %s\n",
8063 GNUNET_i2s (&hops[nhops - 1].hop));
8064 /* sanity check */
8065 if (0 != GNUNET_memcmp (&hops[nhops - 1].hop, &cmc->im.sender))
8066 {
8067 GNUNET_break (0);
8068 finish_cmc_handling (cmc);
8069 return;
8070 }
8071 }
8072
8074 cc = cmc->tc->details.communicator.cc;
8075 bi_hop = (GNUNET_TRANSPORT_CC_RELIABLE ==
8076 cc); // FIXME: add bi-directional flag to cc?
8077 in_time = GNUNET_TIME_absolute_get ();
8078
8079 /* continue communicator here, everything else can happen asynchronous! */
8080 finish_cmc_handling (cmc);
8081
8082 n = lookup_neighbour (&dvl->initiator);
8083 if (NULL != n)
8084 {
8085 if ((n->dv_monotime_available == GNUNET_YES) &&
8088 {
8090 "DV learn from %s discarded due to time travel",
8091 GNUNET_i2s (&dvl->initiator));
8093 "# DV learn discarded due to time travel",
8094 1,
8095 GNUNET_NO);
8096 return;
8097 }
8099 &dvl->initiator,
8100 &dvl->challenge,
8101 &dvl->init_sig))
8102 {
8104 "DV learn signature from %s invalid\n",
8105 GNUNET_i2s (&dvl->initiator));
8106 GNUNET_break_op (0);
8107 return;
8108 }
8111 {
8112 if (NULL != n->sc)
8113 {
8115 "store cancel\n");
8117 }
8118 n->sc =
8120 "transport",
8121 &dvl->initiator,
8123 &dvl->monotonic_time,
8124 sizeof(dvl->monotonic_time),
8128 n);
8129 }
8130 }
8131 /* OPTIMIZE-FIXME: asynchronously (!) verify signatures!,
8132 If signature verification load too high, implement random drop strategy */
8133 for (unsigned int i = 0; i < nhops; i++)
8134 {
8135 struct DvHopPS dhp = { .purpose.purpose =
8137 .purpose.size = htonl (sizeof(dhp)),
8138 .pred = (0 == i) ? dvl->initiator : hops[i - 1].hop,
8139 .succ = (nhops == i + 1) ? GST_my_identity
8140 : hops[i + 1].hop,
8141 .challenge = dvl->challenge };
8142
8143 if (GNUNET_OK !=
8145 &dhp,
8146 &hops[i].hop_sig,
8147 &hops[i].hop.public_key))
8148 {
8150 "DV learn from %s signature of hop %u invalid\n",
8151 GNUNET_i2s (&dvl->initiator),
8152 i);
8154 "signature of hop %s invalid\n",
8155 GNUNET_i2s (&hops[i].hop));
8157 "pred %s\n",
8158 GNUNET_i2s (&dhp.pred));
8160 "succ %s\n",
8161 GNUNET_i2s (&dhp.succ));
8163 "hash %s\n",
8164 GNUNET_sh2s (&dhp.challenge.value));
8165 GNUNET_break_op (0);
8166 return;
8167 }
8168 }
8169 if (GNUNET_EXTRA_LOGGING > 0)
8170 {
8171 char *path;
8172
8173 path = GNUNET_strdup (GNUNET_i2s (&dvl->initiator));
8174 for (unsigned int i = 0; i < nhops; i++)
8175 {
8176 char *tmp;
8177
8178 GNUNET_asprintf (&tmp,
8179 "%s%s%s",
8180 path,
8181 (bi_history & (1 << (nhops - i))) ? "<->" : "-->",
8182 GNUNET_i2s (&hops[i].hop));
8183 GNUNET_free (path);
8184 path = tmp;
8185 }
8187 "Received DVInit via %s%s%s\n",
8188 path,
8189 bi_hop ? "<->" : "-->",
8191 GNUNET_free (path);
8192 }
8193 do_fwd = GNUNET_YES;
8194 if (0 == GNUNET_memcmp (&GST_my_identity, &dvl->initiator))
8195 {
8196 struct GNUNET_PeerIdentity path[nhops + 1];
8197 struct GNUNET_TIME_Relative network_latency;
8198
8199 /* We initiated this, learn the forward path! */
8200 path[0] = GST_my_identity;
8201 path[1] = hops[0].hop;
8202
8203 network_latency = get_network_latency (dvl);
8204
8205 for (unsigned int i = 2; i <= nhops; i++)
8206 {
8207 struct GNUNET_TIME_Relative ilat;
8208
8209 /* assumption: linear latency increase per hop */
8210 ilat = GNUNET_TIME_relative_multiply (network_latency, i);
8211 path[i] = hops[i - 1].hop;
8213 "Learned path with %u hops to %s with latency %s\n",
8214 i,
8215 GNUNET_i2s (&path[i]),
8217 learn_dv_path (path,
8218 i + 1,
8219 ilat,
8222 }
8223 /* as we initiated, do not forward again (would be circular!) */
8224 do_fwd = GNUNET_NO;
8225 return;
8226 }
8227 if (bi_hop)
8228 {
8229 /* last hop was bi-directional, we could learn something here! */
8230 struct GNUNET_PeerIdentity path[nhops + 2];
8231 struct GNUNET_TIME_Relative ilat;
8232 struct GNUNET_TIME_Relative network_latency;
8233
8234 path[0] = GST_my_identity;
8235 path[1] = hops[nhops - 1].hop; /* direct neighbour == predecessor! */
8236 for (unsigned int i = 0; i < nhops; i++)
8237 {
8238 int iret;
8239
8240 if (0 == (bi_history & (1 << i)))
8241 break; /* i-th hop not bi-directional, stop learning! */
8242 if (i == nhops - 1)
8243 {
8244 path[i + 2] = dvl->initiator;
8245 }
8246 else
8247 {
8248 path[i + 2] = hops[nhops - i - 2].hop;
8249 }
8250
8252 "Learned inverse path with %u hops to %s\n",
8253 i + 2,
8254 GNUNET_i2s (&path[i + 2]));
8255 network_latency = get_network_latency (dvl);
8256 ilat = GNUNET_TIME_relative_multiply (network_latency, i + 2);
8257 iret = learn_dv_path (path,
8258 i + 3,
8259 ilat,
8262 if (GNUNET_SYSERR == iret)
8263 {
8264 /* path invalid or too long to be interesting for US, thus should also
8265 not be interesting to our neighbours, cut path when forwarding to
8266 'i' hops, except of course for the one that goes back to the
8267 initiator */
8269 "# DV learn not forwarded due invalidity of path",
8270 1,
8271 GNUNET_NO);
8272 do_fwd = GNUNET_NO;
8273 break;
8274 }
8275 if ((GNUNET_NO == iret) && (nhops == i + 1))
8276 {
8277 /* we have better paths, and this is the longest target,
8278 so there cannot be anything interesting later */
8280 "# DV learn not forwarded, got better paths",
8281 1,
8282 GNUNET_NO);
8283 do_fwd = GNUNET_NO;
8284 break;
8285 }
8286 }
8287 }
8288 if (MAX_DV_HOPS_ALLOWED == nhops)
8289 {
8290 /* At limit, we're out of here! */
8291 return;
8292 }
8293
8294 /* Forward to initiator, if path non-trivial and possible */
8295 bi_history = (bi_history << 1) | (bi_hop ? 1 : 0);
8296 did_initiator = GNUNET_NO;
8297 if ((1 <= nhops) &&
8298 (GNUNET_YES ==
8300 {
8301 /* send back to origin! */
8303 "Sending DVL back to initiator %s\n",
8304 GNUNET_i2s (&dvl->initiator));
8305 forward_dv_learn (&dvl->initiator, dvl, bi_history, nhops, hops, in_time);
8306 did_initiator = GNUNET_YES;
8307 }
8308 /* We forward under two conditions: either we still learned something
8309 ourselves (do_fwd), or the path was darn short and thus the initiator is
8310 likely to still be very interested in this (and we did NOT already
8311 send it back to the initiator) */
8312 if ((do_fwd) || ((nhops < MIN_DV_PATH_LENGTH_FOR_INITIATOR) &&
8313 (GNUNET_NO == did_initiator)))
8314 {
8315 /* Pick random neighbours that are not yet on the path */
8316 struct NeighbourSelectionContext nsc;
8317 unsigned int n_cnt;
8318
8320 nsc.nhops = nhops;
8321 nsc.dvl = dvl;
8322 nsc.bi_history = bi_history;
8323 nsc.hops = hops;
8324 nsc.in_time = in_time;
8325 nsc.num_eligible = 0;
8328 &nsc);
8329 if (0 == nsc.num_eligible)
8330 return; /* done here, cannot forward to anyone else */
8331 nsc.num_selections = calculate_fork_degree (nhops, n_cnt, nsc.num_eligible);
8332 nsc.num_selections =
8333 GNUNET_MIN (MAX_DV_DISCOVERY_SELECTION, nsc.num_selections);
8335 "Forwarding DVL to %u other peers\n",
8336 nsc.num_selections);
8337 for (unsigned int i = 0; i < nsc.num_selections; i++)
8338 nsc.selections[i] =
8339 (nsc.num_selections == n_cnt)
8340 ? i /* all were selected, avoid collisions by chance */
8342 nsc.num_eligible = 0;
8345 &nsc);
8346 }
8347}
static int dv_neighbour_transmission(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Function called for each neighbour during handle_dv_learn.
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 take...
#define MAX_DV_DISCOVERY_SELECTION
Maximum number of peers we select for forwarding DVInit messages at the same time (excluding initiato...
static int dv_neighbour_selection(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
Function called for each neighbour during handle_dv_learn.
static struct GNUNET_TIME_Relative get_network_latency(const struct TransportDVLearnMessage *dvl)
#define ADDRESS_VALIDATION_LIFETIME
How long do we consider an address valid if we just checked?
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 (retur...
static void neighbour_store_dvmono_cb(void *cls, int success)
Function called when peerstore is done storing a DV monotonic time.
#define MIN_DV_PATH_LENGTH_FOR_INITIATOR
Minimum number of hops we should forward DV learn messages even if they are NOT useful for us in hope...
static int validate_dv_initiator_signature(struct GNUNET_TIME_AbsoluteNBO sender_monotonic_time, const struct GNUNET_PeerIdentity *init, const struct GNUNET_CRYPTO_ChallengeNonceP *challenge, const struct GNUNET_CRYPTO_EddsaSignature *init_sig)
Check signature of type GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR.
GNUNET_TRANSPORT_CommunicatorCharacteristics
What characteristics does this communicator have?
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_contains(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Check if the map contains any value under the given key (including values that are NULL).
#define GNUNET_MIN(a, b)
#define GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME
Key used to store sender's monotonic time from DV learn messages.
@ GNUNET_PEERSTORE_STOREOPTION_REPLACE
Delete any previous values for the given key before storing the given value.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
struct GNUNET_PeerIdentity pred
Identity of the previous peer on the path.
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used by the initiator to re-identify the path.
struct GNUNET_PeerIdentity succ
Identity of the next peer on the path.
struct GNUNET_ShortHashCode value
The value of the nonce.
struct GNUNET_TIME_Absolute last_dv_learn_monotime
Latest DVLearn monotonic time seen from this peer.
int dv_monotime_available
Do we have the latest value for last_dv_learn_monotime from PEERSTORE yet, or are we still waiting fo...
enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc
Characteristics of this communicator.
enum ClientType type
What type of client is this?
union TransportClient::@60 details
struct TransportClient::@60::@63 communicator
Information for type CT_COMMUNICATOR.

References GNUNET_TIME_Absolute::abs_value_us, ADDRESS_VALIDATION_LIFETIME, NeighbourSelectionContext::bi_history, TransportDVLearnMessage::bidirectional, calculate_fork_degree(), TransportClient::cc, DvHopPS::challenge, TransportDVLearnMessage::challenge, TransportClient::communicator, CT_COMMUNICATOR, TransportClient::details, Neighbour::dv_monotime_available, dv_neighbour_selection(), dv_neighbour_transmission(), NeighbourSelectionContext::dvl, finish_cmc_handling(), forward_dv_learn(), get_network_latency(), GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_CRYPTO_eddsa_verify, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_EXTRA_LOGGING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MIN, GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_store_cancel(), GNUNET_PEERSTORE_STOREOPTION_REPLACE, GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME, GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP, GNUNET_STATISTICS_update(), GNUNET_strdup, GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_YES, GST_my_identity, GST_stats, DVPathEntryP::hop, NeighbourSelectionContext::hops, CommunicatorMessageContext::im, NeighbourSelectionContext::in_time, TransportDVLearnMessage::init_sig, TransportDVLearnMessage::initiator, Neighbour::last_dv_learn_monotime, learn_dv_path(), lookup_neighbour(), MAX_DV_DISCOVERY_SELECTION, MAX_DV_HOPS_ALLOWED, MIN_DV_PATH_LENGTH_FOR_INITIATOR, TransportDVLearnMessage::monotonic_time, neighbour_store_dvmono_cb(), neighbours, NeighbourSelectionContext::nhops, NeighbourSelectionContext::num_eligible, TransportDVLearnMessage::num_hops, NeighbourSelectionContext::num_selections, peerstore, DvHopPS::pred, GNUNET_CRYPTO_EccSignaturePurpose::purpose, DvHopPS::purpose, Neighbour::sc, NeighbourSelectionContext::selections, GNUNET_TRANSPORT_IncomingMessage::sender, DvHopPS::succ, CommunicatorMessageContext::tc, TransportClient::type, validate_dv_initiator_signature(), and GNUNET_CRYPTO_ChallengeNonceP::value.

Here is the call graph for this function:

◆ check_dv_box()

static int check_dv_box ( void *  cls,
const struct TransportDVBoxMessage dvb 
)
static

Communicator gave us a DV box.

Check the message.

Parameters
clsa struct CommunicatorMessageContext
dvbthe send message that was sent
Returns
GNUNET_YES if message is well-formed

Definition at line 8358 of file gnunet-service-transport.c.

8359{
8360 uint16_t size = ntohs (dvb->header.size);
8361 uint16_t num_hops = ntohs (dvb->num_hops);
8362 const struct GNUNET_PeerIdentity *hops =
8363 (const struct GNUNET_PeerIdentity *) &dvb[1];
8364
8365 (void) cls;
8366 if (size < sizeof(*dvb) + num_hops * sizeof(struct GNUNET_PeerIdentity)
8367 + sizeof(struct GNUNET_MessageHeader))
8368 {
8369 GNUNET_break_op (0);
8370 return GNUNET_SYSERR;
8371 }
8372 /* This peer must not be on the path */
8373 for (unsigned int i = 0; i < num_hops; i++)
8374 if (0 == GNUNET_memcmp (&hops[i], &GST_my_identity))
8375 {
8376 GNUNET_break_op (0);
8377 return GNUNET_SYSERR;
8378 }
8379 return GNUNET_YES;
8380}
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX.

References GNUNET_break_op, GNUNET_memcmp, GNUNET_SYSERR, GNUNET_YES, GST_my_identity, TransportDVBoxMessage::header, TransportDVBoxMessage::num_hops, GNUNET_MessageHeader::size, and size.

◆ forward_dv_box()

static void forward_dv_box ( struct Neighbour next_hop,
struct TransportDVBoxMessage hdr,
uint16_t  total_hops,
uint16_t  num_hops,
const struct GNUNET_PeerIdentity hops,
const void *  enc_payload,
uint16_t  enc_payload_size 
)
static

Create a DV Box message and queue it for transmission to next_hop.

Parameters
next_hoppeer to receive the message next
total_hopshow many hops did the message take so far
num_hopslength of the hops array
originorigin of the message
hopsnext peer(s) to the destination, including destination
payloadpayload of the box
payload_sizenumber of bytes in payload

Definition at line 8396 of file gnunet-service-transport.c.

8403{
8404 struct VirtualLink *vl = next_hop->vl;
8405 struct PendingMessage *pm;
8406 size_t msg_size = sizeof(struct TransportDVBoxMessage)
8407 + num_hops * sizeof(struct GNUNET_PeerIdentity)
8408 + enc_payload_size;
8409 char *buf;
8410 char msg_buf[msg_size] GNUNET_ALIGN;
8411 struct GNUNET_PeerIdentity *dhops;
8412
8413 hdr->num_hops = htons (num_hops);
8414 hdr->total_hops = htons (total_hops);
8415 hdr->header.size = htons (msg_size);
8416 memcpy (msg_buf, hdr, sizeof(*hdr));
8417 dhops = (struct GNUNET_PeerIdentity *) &msg_buf[sizeof(struct
8419 ;
8420 memcpy (dhops, hops, num_hops * sizeof(struct GNUNET_PeerIdentity));
8421 memcpy (&dhops[num_hops], enc_payload, enc_payload_size);
8422
8423 if (GNUNET_YES == ntohs (hdr->without_fc))
8424 {
8426 "Forwarding control message (payload size %u) in DV Box to next hop %s (%u/%u) \n",
8427 enc_payload_size,
8428 GNUNET_i2s (&next_hop->pid),
8429 (unsigned int) num_hops,
8430 (unsigned int) total_hops);
8431 route_via_neighbour (next_hop, (const struct
8432 GNUNET_MessageHeader *) msg_buf,
8434 }
8435 else
8436 {
8437 pm = GNUNET_malloc (sizeof(struct PendingMessage) + msg_size);
8439 "2 created pm %p storing vl %p \n",
8440 pm,
8441 vl);
8442 pm->pmt = PMT_DV_BOX;
8443 pm->vl = vl;
8444 pm->target = next_hop->pid;
8446 pm->logging_uuid = logging_uuid_gen++;
8448 pm->bytes_msg = msg_size;
8449 buf = (char *) &pm[1];
8450 memcpy (buf, msg_buf, msg_size);
8451
8453 "Created pending message %" PRIu64
8454 " for DV Box with next hop %s (%u/%u)\n",
8455 pm->logging_uuid,
8456 GNUNET_i2s (&next_hop->pid),
8457 (unsigned int) num_hops,
8458 (unsigned int) total_hops);
8459
8460 if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
8461 {
8463 vl->pending_msg_head,
8464 vl->pending_msg_tail,
8465 pm);
8466
8468 }
8469 else
8470 {
8472 "The virtual link is not ready for forwarding a DV Box with payload, storing PendingMessage in ring buffer.\n");
8473
8475 {
8477
8478 GNUNET_free (pm_old);
8479 }
8482 {
8485 }
8486 else
8488
8490 "%u items stored in DV ring buffer\n",
8493 }
8494 }
8495}
#define DV_FORWARD_TIMEOUT
If a DVBox could not be forwarded after this number of seconds we drop it.
@ GNUNET_MQ_PRIO_BACKGROUND
Lowest priority, i.e.
unsigned int without_fc
Flag if the payload is a control message.
uint16_t total_hops
Number of total hops this messages travelled.

References check_vl_transmission(), VirtualLink::confirmed, DV_FORWARD_TIMEOUT, GNUNET_ALIGN, GNUNET_CONTAINER_MDLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_MQ_PRIO_BACKGROUND, GNUNET_TIME_relative_to_absolute(), GNUNET_YES, TransportDVBoxMessage::header, is_ring_buffer_dv_full, logging_uuid_gen, TransportDVBoxMessage::num_hops, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, Neighbour::pid, pm, PMT_DV_BOX, ring_buffer_dv, ring_buffer_dv_head, RING_BUFFER_SIZE, RMO_ANYTHING_GOES, route_via_neighbour(), GNUNET_MessageHeader::size, TransportDVBoxMessage::total_hops, Neighbour::vl, and TransportDVBoxMessage::without_fc.

Referenced by handle_dv_box().

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

◆ free_backtalker()

static void free_backtalker ( struct Backtalker b)
static

Free data structures associated with b.

Parameters
bdata structure to release

Definition at line 8504 of file gnunet-service-transport.c.

8505{
8506 if (NULL != b->get)
8507 {
8509 b->get = NULL;
8510 GNUNET_assert (NULL != b->cmc);
8512 b->cmc = NULL;
8513 }
8514 if (NULL != b->task)
8515 {
8517 b->task = NULL;
8518 }
8519 if (NULL != b->sc)
8520 {
8522 "store cancel\n");
8524 b->sc = NULL;
8525 }
8527 "Removing backtalker for %s\n",
8528 GNUNET_i2s (&b->pid));
8530 GNUNET_YES ==
8532 GNUNET_free (b);
8533}
struct CommunicatorMessageContext * cmc
Communicator context waiting on this backchannel's get, or NULL.
struct GNUNET_PEERSTORE_StoreContext * sc
Handle to a PEERSTORE store operation for this pid's monotonic_time.
struct GNUNET_SCHEDULER_Task * task
Task associated with this backtalker.
struct GNUNET_PEERSTORE_IterateContext * get
Handle for an operation to fetch monotonic_time information from the PEERSTORE, or NULL.
struct GNUNET_PeerIdentity pid
Peer this is about.

References backtalkers, Backtalker::cmc, finish_cmc_handling(), Backtalker::get, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_PEERSTORE_iteration_stop(), GNUNET_PEERSTORE_store_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, Backtalker::pid, Backtalker::sc, and Backtalker::task.

Referenced by backtalker_timeout_cb(), and free_backtalker_cb().

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

◆ free_backtalker_cb()

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

Callback to free backtalker records.

Parameters
clsNULL
pidunused
valuea struct Backtalker
Returns
GNUNET_OK (always)

Definition at line 8545 of file gnunet-service-transport.c.

8548{
8549 struct Backtalker *b = value;
8550
8551 (void) cls;
8552 (void) pid;
8553 free_backtalker (b);
8554 return GNUNET_OK;
8555}
static void free_backtalker(struct Backtalker *b)
Free data structures associated with b.
A Backtalker is a peer sending us backchannel messages.

References free_backtalker(), GNUNET_OK, pid, and value.

Referenced by do_shutdown().

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

◆ backtalker_timeout_cb()

static void backtalker_timeout_cb ( void *  cls)
static

Function called when it is time to clean up a backtalker.

Parameters
clsa struct Backtalker

Definition at line 8564 of file gnunet-service-transport.c.

8565{
8566 struct Backtalker *b = cls;
8567
8569 "backtalker timeout.\n");
8570 b->task = NULL;
8572 {
8574 return;
8575 }
8576 GNUNET_assert (NULL == b->sc);
8577 free_backtalker (b);
8578}
static void backtalker_timeout_cb(void *cls)
Function called when it is time to clean up a backtalker.
struct GNUNET_TIME_Absolute timeout
When will this entry time out?

References backtalker_timeout_cb(), free_backtalker(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_at(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_Relative::rel_value_us, Backtalker::sc, Backtalker::task, and Backtalker::timeout.

Referenced by backtalker_monotime_store_cb(), backtalker_timeout_cb(), and handle_dv_box().

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

◆ backtalker_monotime_cb()

static void backtalker_monotime_cb ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Function called with the monotonic time of a backtalker by PEERSTORE.

Updates the time and continues processing.

Parameters
clsa struct Backtalker
recordthe information found, NULL for the last call
emsgerror message

Definition at line 8590 of file gnunet-service-transport.c.

8593{
8594 struct Backtalker *b = cls;
8595 struct GNUNET_TIME_AbsoluteNBO *mtbe;
8596 struct GNUNET_TIME_Absolute mt;
8597
8598 (void) emsg;
8599 if (NULL == record)
8600 {
8601 /* we're done with #backtalker_monotime_cb() invocations,
8602 continue normal processing */
8603 b->get = NULL;
8604 GNUNET_assert (NULL != b->cmc);
8605 b->cmc->mh = (const struct GNUNET_MessageHeader *) &b[1];
8606 if (0 != b->body_size)
8608 else
8610 b->cmc = NULL;
8611 return;
8612 }
8613 if (sizeof(*mtbe) != record->value_size)
8614 {
8616 GNUNET_break (0);
8617 return;
8618 }
8619 mtbe = record->value;
8620 mt = GNUNET_TIME_absolute_ntoh (*mtbe);
8621 if (mt.abs_value_us > b->monotonic_time.abs_value_us)
8622 {
8624 "Backtalker message from %s dropped, monotime in the past\n",
8625 GNUNET_i2s (&b->pid));
8627 GST_stats,
8628 "# Backchannel messages dropped: monotonic time not increasing",
8629 1,
8630 GNUNET_NO);
8631 b->monotonic_time = mt;
8632 /* Setting body_size to 0 prevents call to #forward_backchannel_payload()
8633 */
8634 b->body_size = 0;
8635 }
8637}
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
void GNUNET_PEERSTORE_iteration_next(struct GNUNET_PEERSTORE_IterateContext *ic, uint64_t limit)
Continue an iteration.
size_t body_size
Number of bytes of the original message body that follows after this struct.
struct GNUNET_TIME_Absolute monotonic_time
Last (valid) monotonic time received from this sender.
Time for absolute time used by GNUnet, in microseconds and in network byte order.

References GNUNET_TIME_Absolute::abs_value_us, Backtalker::body_size, Backtalker::cmc, demultiplex_with_cmc(), finish_cmc_handling(), Backtalker::get, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_PEERSTORE_iteration_next(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GST_stats, CommunicatorMessageContext::mh, Backtalker::monotonic_time, Backtalker::pid, and record().

Referenced by handle_dv_box().

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

◆ backtalker_monotime_store_cb()

static void backtalker_monotime_store_cb ( void *  cls,
int  success 
)
static

Function called by PEERSTORE when the store operation of a backtalker's monotonic time is complete.

Parameters
clsthe struct Backtalker
successGNUNET_OK on success

Definition at line 8648 of file gnunet-service-transport.c.

8649{
8650 struct Backtalker *b = cls;
8651
8652 if (GNUNET_OK != success)
8653 {
8655 "Failed to store backtalker's monotonic time in PEERSTORE!\n");
8656 }
8657 b->sc = NULL;
8658 if (NULL != b->task)
8659 {
8661 b->task = NULL;
8662 }
8664}

References backtalker_timeout_cb(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), Backtalker::sc, Backtalker::task, and Backtalker::timeout.

Referenced by update_backtalker_monotime().

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

◆ update_backtalker_monotime()

static void update_backtalker_monotime ( struct Backtalker b)
static

The backtalker b monotonic time changed.

Update PEERSTORE.

Parameters
ba backtalker with updated monotonic time

Definition at line 8673 of file gnunet-service-transport.c.

8674{
8675 struct GNUNET_TIME_AbsoluteNBO mtbe;
8676
8677 if (NULL != b->sc)
8678 {
8680 "store cancel before store with sc %p\n",
8681 b->sc);
8682 /*GNUNET_PEERSTORE_store_cancel (b->sc);
8683 b->sc = NULL;*/
8685 "store cancel before store with sc %p is null\n",
8686 b->sc);
8687 }
8688 else
8689 {
8691 b->task = NULL;
8692 }
8694 b->sc =
8696 "transport",
8697 &b->pid,
8699 &mtbe,
8700 sizeof(mtbe),
8704 b);
8705}
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.
#define GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME
Key used to store sender's monotonic time from backchannel messages.

References backtalker_monotime_store_cb(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_STOREOPTION_REPLACE, GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME, GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_FOREVER_ABS, Backtalker::monotonic_time, peerstore, Backtalker::pid, Backtalker::sc, and Backtalker::task.

Referenced by handle_dv_box().

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

◆ handle_dv_box()

static void handle_dv_box ( void *  cls,
const struct TransportDVBoxMessage dvb 
)
static

Communicator gave us a DV box.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
dvbthe message that was received

Definition at line 8716 of file gnunet-service-transport.c.

8717{
8718 struct CommunicatorMessageContext *cmc = cls;
8719 uint16_t size = ntohs (dvb->header.size) - sizeof(*dvb);
8720 uint16_t num_hops = ntohs (dvb->num_hops);
8721 const struct GNUNET_PeerIdentity *hops =
8722 (const struct GNUNET_PeerIdentity *) &dvb[1];
8723 const char *enc_payload = (const char *) &hops[num_hops];
8724 uint16_t enc_payload_size =
8725 size - (num_hops * sizeof(struct GNUNET_PeerIdentity));
8726 struct DVKeyState key;
8727 struct GNUNET_HashCode hmac;
8728 const char *hdr;
8729 size_t hdr_len;
8730
8731 if (GNUNET_EXTRA_LOGGING > 0)
8732 {
8733 char *path;
8734
8736 for (unsigned int i = 0; i < num_hops; i++)
8737 {
8738 char *tmp;
8739
8740 GNUNET_asprintf (&tmp, "%s->%s", path, GNUNET_i2s (&hops[i]));
8741 GNUNET_free (path);
8742 path = tmp;
8743 }
8745 "Received DVBox with remaining path %s\n",
8746 path);
8747 GNUNET_free (path);
8748 }
8749
8750 if (num_hops > 0)
8751 {
8752 /* We're trying from the end of the hops array, as we may be
8753 able to find a shortcut unknown to the origin that way */
8754 for (int i = num_hops - 1; i >= 0; i--)
8755 {
8756 struct Neighbour *n;
8757
8758 if (0 == GNUNET_memcmp (&hops[i], &GST_my_identity))
8759 {
8760 GNUNET_break_op (0);
8761 finish_cmc_handling (cmc);
8762 return;
8763 }
8764 n = lookup_neighbour (&hops[i]);
8765 if (NULL == n)
8766 continue;
8768 "Skipping %u/%u hops ahead while routing DV Box\n",
8769 i,
8770 num_hops);
8771
8772 forward_dv_box (n,
8773 (struct TransportDVBoxMessage *) dvb,
8774 ntohs (dvb->total_hops) + 1,
8775 num_hops - i - 1, /* number of hops left */
8776 &hops[i + 1], /* remaining hops */
8777 enc_payload,
8778 enc_payload_size);
8780 "# DV hops skipped routing boxes",
8781 i,
8782 GNUNET_NO);
8784 "# DV boxes routed (total)",
8785 1,
8786 GNUNET_NO);
8787 finish_cmc_handling (cmc);
8788 return;
8789 }
8790 /* Woopsie, next hop not in neighbours, drop! */
8792 "# DV Boxes dropped: next hop unknown",
8793 1,
8794 GNUNET_NO);
8795 finish_cmc_handling (cmc);
8796 return;
8797 }
8798 /* We are the target. Unbox and handle message. */
8800 "# DV boxes opened (ultimate target)",
8801 1,
8802 GNUNET_NO);
8803 cmc->total_hops = ntohs (dvb->total_hops);
8804
8805 // DH key derivation with received DV, could be garbage.
8806 {
8807 struct GNUNET_ShortHashCode km;
8808
8810 &dvb->ephemeral_key,
8811 &km))
8812 {
8813 GNUNET_break_op (0);
8814 finish_cmc_handling (cmc);
8815 return;
8816 }
8817 dv_setup_key_state_from_km (&km, &dvb->iv, &key);
8818 }
8819 hdr = (const char *) &dvb[1];
8820 hdr_len = ntohs (dvb->orig_size) - sizeof(*dvb) - sizeof(struct
8822 * ntohs (dvb->total_hops);
8823
8824 dv_hmac (&key, &hmac, hdr, hdr_len);
8825 if (0 != GNUNET_memcmp (&hmac, &dvb->hmac))
8826 {
8827 /* HMAC mismatch, discard! */
8828 GNUNET_break_op (0);
8829 finish_cmc_handling (cmc);
8830 return;
8831 }
8832 /* begin actual decryption */
8833 {
8834 struct Backtalker *b;
8835 struct GNUNET_TIME_Absolute monotime;
8836 struct TransportDVBoxPayloadP ppay;
8837 char body[hdr_len - sizeof(ppay)] GNUNET_ALIGN;
8838 const struct GNUNET_MessageHeader *mh;
8839
8840 GNUNET_assert (hdr_len >=
8841 sizeof(ppay) + sizeof(struct GNUNET_MessageHeader));
8842 if (GNUNET_OK != dv_decrypt (&key, &ppay, hdr, sizeof(ppay)))
8843 {
8845 "Error decrypting DV payload header\n");
8846 GNUNET_break_op (0);
8847 finish_cmc_handling (cmc);
8848 return;
8849 }
8850 if (GNUNET_OK != dv_decrypt (&key, body,
8851 &hdr[sizeof(ppay)], hdr_len - sizeof(ppay)))
8852 {
8854 "Error decrypting DV payload\n");
8855 GNUNET_break_op (0);
8856 finish_cmc_handling (cmc);
8857 return;
8858 }
8859 mh = (const struct GNUNET_MessageHeader *) body;
8860 dv_key_clean (&key);
8861 if (ntohs (mh->size) != sizeof(body))
8862 {
8863 GNUNET_break_op (0);
8864 finish_cmc_handling (cmc);
8865 return;
8866 }
8867 /* need to prevent box-in-a-box (and DV_LEARN) so check inbox type! */
8868 switch (ntohs (mh->type))
8869 {
8871 GNUNET_break_op (0);
8872 finish_cmc_handling (cmc);
8873 return;
8874
8876 GNUNET_break_op (0);
8877 finish_cmc_handling (cmc);
8878 return;
8879
8880 default:
8881 /* permitted, continue */
8882 break;
8883 }
8884 monotime = GNUNET_TIME_absolute_ntoh (ppay.monotonic_time);
8886 "Decrypted backtalk from %s\n",
8887 GNUNET_i2s (&ppay.sender));
8889 if ((NULL != b) && (monotime.abs_value_us < b->monotonic_time.abs_value_us))
8890 {
8892 GST_stats,
8893 "# Backchannel messages dropped: monotonic time not increasing",
8894 1,
8895 GNUNET_NO);
8896 finish_cmc_handling (cmc);
8897 return;
8898 }
8899 if ((NULL == b) ||
8900 (0 != GNUNET_memcmp (&b->last_ephemeral, &dvb->ephemeral_key)))
8901 {
8902 /* Check signature */
8903 struct EphemeralConfirmationPS ec;
8904
8906 ec.target = GST_my_identity;
8907 ec.ephemeral_key = dvb->ephemeral_key;
8908 ec.purpose.size = htonl (sizeof(ec));
8909 ec.sender_monotonic_time = ppay.monotonic_time;
8910 if (
8911 GNUNET_OK !=
8914 &ec,
8915 &ppay.sender_sig,
8916 &ppay.sender.public_key))
8917 {
8918 /* Signature invalid, discard! */
8919 GNUNET_break_op (0);
8920 finish_cmc_handling (cmc);
8921 return;
8922 }
8923 }
8924 /* Update sender, we now know the real origin! */
8926 "DVBox received for me from %s via %s\n",
8927 GNUNET_i2s2 (&ppay.sender),
8928 GNUNET_i2s (&cmc->im.sender));
8929 cmc->im.sender = ppay.sender;
8930
8931 if (NULL != b)
8932 {
8933 /* update key cache and mono time */
8934 b->last_ephemeral = dvb->ephemeral_key;
8935 b->monotonic_time = monotime;
8937 b->timeout =
8939 cmc->mh = mh;
8941 return;
8942 }
8943 /* setup data structure to cache signature AND check
8944 monotonic time with PEERSTORE before forwarding backchannel payload */
8945 b = GNUNET_malloc (sizeof(struct Backtalker) + sizeof(body));
8946 b->pid = ppay.sender;
8947 b->body_size = sizeof(body);
8948 memcpy (&b[1], body, sizeof(body));
8952 &b->pid,
8953 b,
8955 b->monotonic_time = monotime; /* NOTE: to be checked still! */
8956 b->cmc = cmc;
8957 b->timeout =
8960 b->get =
8962 "transport",
8963 &b->pid,
8966 b);
8967 } /* end actual decryption */
8968}
static enum GNUNET_GenericReturnValue 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.
static void update_backtalker_monotime(struct Backtalker *b)
The backtalker b monotonic time changed.
#define BACKCHANNEL_INACTIVITY_TIMEOUT
How long do we cache backchannel (struct Backtalker) information after a backchannel goes inactive?
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.
static void forward_dv_box(struct Neighbour *next_hop, struct TransportDVBoxMessage *hdr, uint16_t total_hops, uint16_t num_hops, const struct GNUNET_PeerIdentity *hops, const void *enc_payload, uint16_t enc_payload_size)
Create a DV Box message and queue it for transmission to next_hop.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_kem_decaps(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_HpkeEncapsulation *c, struct GNUNET_ShortHashCode *prk)
Decapsulate a key for a private EdDSA key.
Definition: crypto_hpke.c:407
struct GNUNET_PEERSTORE_IterateContext * GNUNET_PEERSTORE_iteration_start(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Iterate over peerstore entries.
struct GNUNET_CRYPTO_HpkeEncapsulation last_ephemeral
Last (valid) ephemeral key received from this sender.
uint16_t total_hops
Number of hops the message has travelled (if DV-routed).
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose is GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL.
A 512-bit hashcode.
struct GNUNET_HashCode hmac
HMAC over the ciphertext of the encrypted, variable-size body that follows.
uint16_t orig_size
Size this msg had initially.
struct GNUNET_CRYPTO_HpkeEncapsulation ephemeral_key
Ephemeral key setup by the sender for target, used to encrypt the payload.
struct GNUNET_ShortHashCode iv
We use an IV here as the ephemeral_key is re-used for EPHEMERAL_VALIDITY time to avoid re-signing it ...

References GNUNET_TIME_Absolute::abs_value_us, BACKCHANNEL_INACTIVITY_TIMEOUT, backtalker_monotime_cb(), backtalker_timeout_cb(), backtalkers, Backtalker::body_size, Backtalker::cmc, demultiplex_with_cmc(), dv_decrypt(), dv_hmac(), dv_key_clean(), dv_setup_key_state_from_km(), EphemeralConfirmationPS::ephemeral_key, TransportDVBoxMessage::ephemeral_key, finish_cmc_handling(), forward_dv_box(), Backtalker::get, GNUNET_ALIGN, GNUNET_asprintf(), GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_eddsa_kem_decaps(), GNUNET_CRYPTO_eddsa_verify, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_EXTRA_LOGGING, GNUNET_free, GNUNET_i2s(), GNUNET_i2s2(), GNUNET_log, GNUNET_malloc, GNUNET_memcmp, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN, GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_iteration_start(), GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME, GNUNET_SCHEDULER_add_at(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL, GNUNET_STATISTICS_update(), GNUNET_strdup, GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GST_my_identity, GST_my_private_key, GST_stats, TransportDVBoxMessage::header, TransportDVBoxMessage::hmac, CommunicatorMessageContext::im, TransportDVBoxMessage::iv, key, Backtalker::last_ephemeral, lookup_neighbour(), mh, CommunicatorMessageContext::mh, TransportDVBoxPayloadP::monotonic_time, Backtalker::monotonic_time, TransportDVBoxMessage::num_hops, TransportDVBoxMessage::orig_size, peerstore, Backtalker::pid, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, EphemeralConfirmationPS::purpose, TransportDVBoxPayloadP::sender, GNUNET_TRANSPORT_IncomingMessage::sender, EphemeralConfirmationPS::sender_monotonic_time, TransportDVBoxPayloadP::sender_sig, GNUNET_MessageHeader::size, GNUNET_CRYPTO_EccSignaturePurpose::size, size, EphemeralConfirmationPS::target, Backtalker::task, Backtalker::timeout, TransportDVBoxMessage::total_hops, CommunicatorMessageContext::total_hops, and update_backtalker_monotime().

Here is the call graph for this function:

◆ check_incoming_msg()

static int check_incoming_msg ( void *  cls,
const struct GNUNET_TRANSPORT_IncomingMessage im 
)
static

Client notified us about transmission from a peer.

Process the request.

Parameters
clsa struct TransportClient which sent us the message
imthe send message that was sent
Returns
GNUNET_YES if message is well-formed

Definition at line 8979 of file gnunet-service-transport.c.

8981{
8982 struct TransportClient *tc = cls;
8983
8984 if (CT_COMMUNICATOR != tc->type)
8985 {
8986 GNUNET_break (0);
8987 return GNUNET_SYSERR;
8988 }
8990 return GNUNET_OK;
8991}

References CT_COMMUNICATOR, GNUNET_break, GNUNET_MQ_check_boxed_message, GNUNET_OK, GNUNET_SYSERR, and tc.

◆ check_known_address()

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

Test if the validation state in value matches the address from cls.

Parameters
clsa struct CheckKnownAddressContext
pidunused (must match though)
valuea struct ValidationState
Returns
GNUNET_OK if not matching, GNUNET_NO if match found

Definition at line 9021 of file gnunet-service-transport.c.

9024{
9025 struct CheckKnownAddressContext *ckac = cls;
9026 struct ValidationState *vs = value;
9027
9028 (void) pid;
9029 if (0 != strcmp (vs->address, ckac->address))
9030 return GNUNET_OK;
9031 ckac->vs = vs;
9032 return GNUNET_NO;
9033}
Closure for check_known_address.
struct ValidationState * vs
Set to a matching validation state, if one was found.
const char * address
Set to the address we are looking for.
State we keep for validation activities.

References CheckKnownAddressContext::address, GNUNET_NO, GNUNET_OK, pid, value, and CheckKnownAddressContext::vs.

Referenced by start_address_validation().

Here is the caller graph for this function:

◆ validation_start_cb()

static void validation_start_cb ( void *  cls)
static

Task run periodically to validate some address based on validation_heap.

Parameters
clsNULL

Definition at line 11652 of file gnunet-service-transport.c.

11653{
11654 struct ValidationState *vs;
11655 struct Queue *q;
11657 GST_cfg);
11658
11659 (void) cls;
11660 validation_task = NULL;
11662 /* drop validations past their expiration */
11663 while (
11664 (NULL != vs) &&
11666 {
11668 "Validation response %s cleaned up\n",
11669 GNUNET_sh2s (&vs->challenge.value));
11672 }
11673 if (NULL == vs)
11674 {
11676 "Address validation task not scheduled anymore, nothing to do\n");
11677 return; /* woopsie, no more addresses known, should only
11678 happen if we're really a lonely peer */
11679 }
11680 q = find_queue (&vs->pid, vs->address);
11681 if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
11682 {
11684 "To early to start next address validation for challenge %s\n",
11685 GNUNET_sh2s (&vs->challenge.value));
11686 return;
11687 }
11688 if (NULL == q)
11689 {
11690 vs->awaiting_queue = GNUNET_YES;
11691 suggest_to_connect (&vs->pid, vs->address);
11692 }
11693 else
11695 /* Finally, reschedule next attempt */
11696 vs->challenge_backoff =
11697 GNUNET_TIME_randomized_backoff (vs->challenge_backoff,
11700 "Address validation task will run again in %s\n",
11701 GNUNET_STRINGS_relative_time_to_string (vs->challenge_backoff,
11702 GNUNET_YES));
11705 vs->challenge_backoff));
11706}
static void free_validation_state(struct ValidationState *vs)
Free validation state.
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...
static struct Queue * find_queue(const struct GNUNET_PeerIdentity *pid, const char *address)
Find the queue matching pid and address.
#define MAX_VALIDATION_CHALLENGE_FREQ
What is the slowest rate at which we send challenges?
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.
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.
struct GNUNET_TIME_Relative GNUNET_TIME_randomized_backoff(struct GNUNET_TIME_Relative rt, struct GNUNET_TIME_Relative threshold)
Randomized exponential back-off, starting at 1 ms and going up by a factor of 2+r,...
Definition: time.c:834
#define GNUNET_TIME_absolute_cmp(t1, op, t2)
Compare two absolute times.
struct GNUNET_TIME_Absolute valid_until
How long did the peer claim this address to be valid? Capped at minimum of MAX_ADDRESS_VALID_UNTIL re...

References find_queue(), free_validation_state(), GNUNET_CONTAINER_heap_peek(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_sh2s(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_randomized_backoff(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GST_cfg, MAX_VALIDATION_CHALLENGE_FREQ, ValidationState::pid, q, GNUNET_TIME_Relative::rel_value_us, suggest_to_connect(), update_next_challenge_time(), ValidationState::valid_until, validation_heap, validation_task, and validation_transmit_on_queue().

Referenced by update_next_challenge_time().

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

◆ update_next_challenge_time()

static void update_next_challenge_time ( struct ValidationState vs,
struct GNUNET_TIME_Absolute  new_time 
)
static

Set the time for next_challenge of vs to new_time.

Updates the heap and if necessary reschedules the job.

Parameters
vsvalidation state to update
new_timenew time for revalidation

Definition at line 9053 of file gnunet-service-transport.c.

9055{
9057
9058 if (new_time.abs_value_us == vs->next_challenge.abs_value_us)
9059 return; /* be lazy */
9060 vs->next_challenge = new_time;
9061 if (NULL == vs->hn)
9062 vs->hn =
9064 else
9067 (NULL != validation_task))
9068 return;
9069 if (NULL != validation_task)
9071 /* randomize a bit */
9074 MIN_DELAY_ADDRESS_VALIDATION.rel_value_us);
9075 new_time = GNUNET_TIME_absolute_add (new_time, delta);
9078}
#define MIN_DELAY_ADDRESS_VALIDATION
What is the maximum frequency at which we do address validation? A random value between 0 and this va...
static void validation_start_cb(void *cls)
Task run periodically to validate some address based on validation_heap.
void GNUNET_CONTAINER_heap_update_cost(struct GNUNET_CONTAINER_HeapNode *node, GNUNET_CONTAINER_HeapCostType new_cost)
Updates the cost of any node in the tree.

References GNUNET_TIME_Absolute::abs_value_us, delta, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_heap_update_cost(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_add(), MIN_DELAY_ADDRESS_VALIDATION, GNUNET_TIME_Relative::rel_value_us, validation_heap, validation_start_cb(), and validation_task.

Referenced by handle_validation_response(), revalidation_start_cb(), start_address_validation(), and validation_start_cb().

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

◆ start_address_validation()

static void start_address_validation ( const struct GNUNET_PeerIdentity pid,
const char *  address 
)
static

Start address validation.

Parameters
pidpeer the address is for
addressan address to reach pid (presumably)

Definition at line 9088 of file gnunet-service-transport.c.

9090{
9091 struct GNUNET_TIME_Absolute now;
9092 struct ValidationState *vs;
9093 struct CheckKnownAddressContext ckac = { .address = address, .vs = NULL };
9094
9096 pid,
9098 &ckac);
9099 if (NULL != (vs = ckac.vs))
9100 {
9101 /* if 'vs' is not currently valid, we need to speed up retrying the
9102 * validation */
9103 if (vs->validated_until.abs_value_us < vs->next_challenge.abs_value_us)
9104 {
9105 /* reduce backoff as we got a fresh advertisement */
9106 vs->challenge_backoff =
9109 vs->challenge_backoff,
9110 2));
9113 vs->challenge_backoff));
9114 }
9115 return;
9116 }
9118 vs = GNUNET_new (struct ValidationState);
9119 vs->pid = *pid;
9120 vs->valid_until =
9122 vs->first_challenge_use = now;
9123 vs->validation_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
9125 &vs->challenge,
9126 sizeof(vs->challenge));
9127 vs->address = GNUNET_strdup (address);
9128 GNUNET_CRYPTO_hash (vs->address, strlen (vs->address), &vs->hc);
9130 "Starting address validation `%s' of peer %s using challenge %s\n",
9131 address,
9132 GNUNET_i2s (pid),
9133 GNUNET_sh2s (&vs->challenge.value));
9137 &vs->pid,
9138 vs,
9141}
#define FAST_VALIDATION_CHALLENGE_FREQ
What is the fastest rate at which we send challenges if we keep learning an address (gossip,...
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.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
struct GNUNET_TIME_Absolute validated_until
How long do we consider this address to be valid? In the past or zero if we have not yet validated it...

References GNUNET_TIME_Absolute::abs_value_us, address, CheckKnownAddressContext::address, ADDRESS_VALIDATION_LIFETIME, check_known_address(), FAST_VALIDATION_CHALLENGE_FREQ, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_block(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_sh2s(), GNUNET_strdup, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GST_cfg, ValidationState::pid, pid, update_next_challenge_time(), ValidationState::valid_until, ValidationState::validated_until, validation_map, and CheckKnownAddressContext::vs.

Referenced by handle_add_queue_message(), handle_request_hello_validation(), handle_validation_challenge(), hello_for_client_cb(), and hello_for_incoming_cb().

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

◆ find_queue()

static struct Queue * find_queue ( const struct GNUNET_PeerIdentity pid,
const char *  address 
)
static

Find the queue matching pid and address.

Parameters
pidpeer the queue must go to
addressaddress the queue must use
Returns
NULL if no such queue exists

Definition at line 9428 of file gnunet-service-transport.c.

9429{
9430 struct Neighbour *n;
9431
9432 n = lookup_neighbour (pid);
9433 if (NULL == n)
9434 return NULL;
9435 for (struct Queue *pos = n->queue_head; NULL != pos;
9436 pos = pos->next_neighbour)
9437 {
9438 if (0 == strcmp (pos->address, address))
9439 return pos;
9440 }
9441 return NULL;
9442}

References address, lookup_neighbour(), Queue::next_neighbour, pid, and Neighbour::queue_head.

Referenced by handle_request_hello_validation(), handle_validation_response(), hello_for_client_cb(), hello_for_incoming_cb(), revalidation_start_cb(), and validation_start_cb().

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

◆ suggest_to_connect()

static void suggest_to_connect ( const struct GNUNET_PeerIdentity pid,
const char *  address 
)
static

Signature of a function called with a communicator address of a peer pid that an application wants us to connect to.

Parameters
pidtarget peer
addressthe address to try

Definition at line 11548 of file gnunet-service-transport.c.

11549{
11550 static uint32_t idgen;
11551 struct TransportClient *tc;
11552 char *prefix;
11553 struct GNUNET_TRANSPORT_CreateQueue *cqm;
11554 struct GNUNET_MQ_Envelope *env;
11555 size_t alen;
11556
11558 if (NULL == prefix)
11559 {
11560 GNUNET_break (0); /* We got an invalid address!? */
11561 return;
11562 }
11564 if (NULL == tc)
11565 {
11567 "# Suggestions ignored due to missing communicator",
11568 1,
11569 GNUNET_NO);
11571 "Cannot connect to %s at `%s', no matching communicator present\n",
11572 GNUNET_i2s (pid),
11573 address);
11575 return;
11576 }
11577 /* forward suggestion for queue creation to communicator */
11579 "Request #%u for `%s' communicator to create queue to `%s' at `%s'\n",
11580 (unsigned int) idgen,
11581 prefix,
11582 GNUNET_i2s (pid),
11583 address);
11585 alen = strlen (address) + 1;
11586 env =
11588 cqm->request_id = htonl (idgen++);
11589 cqm->receiver = *pid;
11590 memcpy (&cqm[1], address, alen);
11591 GNUNET_MQ_send (tc->mq, env);
11592}
static struct TransportClient * lookup_communicator(const char *prefix)
Find transport client providing communication service for the protocol prefix.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE
transport tells communicator it wants a queue
Transport tells communicator that it wants a new queue.
Definition: transport.h:521
uint32_t request_id
Unique ID for the request.
Definition: transport.h:530
struct GNUNET_PeerIdentity receiver
Receiver that can be addressed via the queue.
Definition: transport.h:535

References address, env, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELLO_address_to_prefix(), GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GST_stats, lookup_communicator(), pid, prefix, GNUNET_TRANSPORT_CreateQueue::receiver, GNUNET_TRANSPORT_CreateQueue::request_id, and tc.

Referenced by handle_request_hello_validation(), hello_for_client_cb(), hello_for_incoming_cb(), revalidation_start_cb(), and validation_start_cb().

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

◆ hello_for_incoming_cb()

static void hello_for_incoming_cb ( void *  cls,
const struct GNUNET_PeerIdentity pid,
const char *  uri 
)
static

Definition at line 9153 of file gnunet-service-transport.c.

9156{
9157 struct Queue *q;
9158 int pfx_len;
9159 const char *eou;
9160 char *address;
9161 (void) cls;
9162
9163 eou = strstr (uri,
9164 "://");
9165 pfx_len = eou - uri;
9166 eou += 3;
9168 "%.*s-%s",
9169 pfx_len,
9170 uri,
9171 eou);
9172
9174 "helo for client %s\n",
9175 address);
9176 q = find_queue (pid, address);
9177 if (NULL == q)
9178 {
9180 }
9181 else
9184}
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static void start_address_validation(const struct GNUNET_PeerIdentity *pid, const char *address)
Start address validation.

References address, find_queue(), GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, pid, q, start_address_validation(), suggest_to_connect(), and uri.

Referenced by handle_hello_for_incoming().

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

◆ handle_hello_for_incoming()

static void handle_hello_for_incoming ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Function called by PEERSTORE for each matching record.

Parameters
clsclosure, a struct IncomingRequest
recordpeerstore record information
emsgerror message, or NULL if no errors

Definition at line 9195 of file gnunet-service-transport.c.

9198{
9199 struct IncomingRequest *ir = cls;
9201 struct GNUNET_MessageHeader *hello;
9202
9203 if (NULL != emsg)
9204 {
9206 "Got failure from PEERSTORE: %s\n",
9207 emsg);
9208 return;
9209 }
9210 hello = record->value;
9211 if (0 == GNUNET_memcmp (&record->peer, &GST_my_identity))
9212 {
9214 return;
9215 }
9219 NULL);
9221}
static void hello_for_incoming_cb(void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
void GNUNET_HELLO_parser_free(struct GNUNET_HELLO_Parser *parser)
Release resources of a builder.
Definition: hello-uri.c:435
struct GNUNET_HELLO_Parser * GNUNET_HELLO_parser_from_msg(const struct GNUNET_MessageHeader *msg)
Parse msg.
Definition: hello-uri.c:471
const struct GNUNET_PeerIdentity * GNUNET_HELLO_parser_iterate(const struct GNUNET_HELLO_Parser *parser, GNUNET_HELLO_UriCallback uc, void *uc_cls)
Iterate over URIs in a parser.
Definition: hello-uri.c:1201
void GNUNET_PEERSTORE_monitor_next(struct GNUNET_PEERSTORE_Monitor *zm, uint64_t limit)
Calls the monitor processor specified in GNUNET_PEERSTORE_monitor_start for the next record(s).
Context for parsing HELLOs.
Definition: hello-uri.c:258
Another peer attempted to talk to us, we should try to establish a connection in the other direction.

References GNUNET_ERROR_TYPE_WARNING, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_iterate(), GNUNET_log, GNUNET_memcmp, GNUNET_PEERSTORE_monitor_next(), GST_my_identity, hello_for_incoming_cb(), IncomingRequest::nc, consensus-simulation::parser, and record().

Referenced by handle_validation_challenge().

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

◆ hello_for_incoming_error_cb()

static void hello_for_incoming_error_cb ( void *  cls)
static

Definition at line 9225 of file gnunet-service-transport.c.

9226{
9228 "Error in PEERSTORE monitoring\n");
9229}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by handle_validation_challenge().

Here is the caller graph for this function:

◆ hello_for_incoming_sync_cb()

static void hello_for_incoming_sync_cb ( void *  cls)
static

Definition at line 9233 of file gnunet-service-transport.c.

9234{
9236 "Done with initial PEERSTORE iteration during monitoring\n");
9237}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by handle_validation_challenge().

Here is the caller graph for this function:

◆ handle_validation_challenge()

static void handle_validation_challenge ( void *  cls,
const struct TransportValidationChallengeMessage tvc 
)
static

Communicator gave us a transport address validation challenge.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
tvcthe message that was received

Definition at line 9249 of file gnunet-service-transport.c.

9252{
9253 struct CommunicatorMessageContext *cmc = cls;
9255 struct VirtualLink *vl;
9256 struct GNUNET_TIME_RelativeNBO validity_duration;
9257 struct IncomingRequest *ir;
9258 struct Neighbour *n;
9259 struct GNUNET_PeerIdentity sender;
9260
9261 /* DV-routed messages are not allowed for validation challenges */
9262 if (cmc->total_hops > 0)
9263 {
9264 GNUNET_break_op (0);
9265 finish_cmc_handling (cmc);
9266 return;
9267 }
9268 validity_duration = cmc->im.expected_address_validity;
9270 "Received address validation challenge %s\n",
9271 GNUNET_sh2s (&tvc->challenge.value));
9272 /* If we have a virtual link, we use this mechanism to signal the
9273 size of the flow control window, and to allow the sender
9274 to ask for increases. If for us the virtual link is still down,
9275 we will always give a window size of zero. */
9276 tvr.header.type =
9278 tvr.header.size = htons (sizeof(tvr));
9279 tvr.reserved = htonl (0);
9280 tvr.challenge = tvc->challenge;
9281 tvr.origin_time = tvc->sender_time;
9282 tvr.validity_duration = validity_duration;
9283 {
9284 /* create signature */
9285 struct TransportValidationPS tvp = {
9287 .purpose.size = htonl (sizeof(tvp)),
9288 .validity_duration = validity_duration,
9289 .challenge = tvc->challenge
9290 };
9291
9293 &tvp,
9294 &tvr.signature);
9295 }
9296 sender = cmc->im.sender;
9297 vl = lookup_virtual_link (&sender);
9298 if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
9299 {
9300 // route_control_message_without_fc (&cmc->im.sender,
9302 &tvr.header,
9304 }
9305 else
9306 {
9307 /* Use route via neighbour */
9308 n = lookup_neighbour (&sender);
9309 if (NULL != n)
9310 route_via_neighbour (n, &tvr.header,
9313 }
9314
9315 finish_cmc_handling (cmc);
9316 if (NULL != vl)
9317 return;
9318
9319 /* For us, the link is still down, but we need bi-directional
9320 connections (for flow-control and for this to be useful for
9321 CORE), so we must try to bring the link up! */
9322
9323 /* (1) Check existing queues, if any, we may be lucky! */
9324 n = lookup_neighbour (&sender);
9325 if (NULL != n)
9326 for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
9327 start_address_validation (&sender, q->address);
9328 /* (2) Also try to see if we have addresses in PEERSTORE for this peer
9329 we could use */
9330 for (ir = ir_head; NULL != ir; ir = ir->next)
9331 if (0 == GNUNET_memcmp (&ir->pid, &sender))
9332 return;
9333 /* we are already trying */
9334 ir = GNUNET_new (struct IncomingRequest);
9335 ir->pid = sender;
9337
9339 GNUNET_YES,
9340 "peerstore",
9341 NULL,
9344 NULL,
9346 NULL,
9348 ir);
9349 ir_total++;
9350 /* Bound attempts we do in parallel here, might otherwise get excessive */
9353}
static void hello_for_incoming_sync_cb(void *cls)
static void hello_for_incoming_error_cb(void *cls)
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.
#define MAX_INCOMING_REQUEST
For how many incoming connections do we try to create a virtual link for (at the same time!...
#define GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE
Signature by a peer affirming that it received a challenge (and stating how long it expects the addre...
struct GNUNET_PEERSTORE_Monitor * GNUNET_PEERSTORE_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, int iterate_first, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Request watching a given key The monitoring can be filtered to contain only records matching peer and...
#define GNUNET_PEERSTORE_HELLO_KEY
Key used for storing HELLO in the peerstore.
Time for relative time used by GNUnet, in microseconds and in network byte order.
struct GNUNET_TIME_RelativeNBO expected_address_validity
How long does the communicator believe the address on which the message was received to remain valid?
Definition: transport.h:353
struct IncomingRequest * next
Kept in a DLL.
struct GNUNET_PeerIdentity pid
Which peer is this about?
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge to be signed by the receiving peer.
struct GNUNET_TIME_AbsoluteNBO sender_time
Timestamp of the sender, to be copied into the reply to allow sender to calculate RTT.
Message signed by a peer to confirm that it can indeed receive messages at a particular address.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose is GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE.
struct GNUNET_TIME_RelativeNBO validity_duration
How long does the sender believe the address on which the challenge was received to remain valid?

References TransportValidationChallengeMessage::challenge, TransportValidationResponseMessage::challenge, VirtualLink::confirmed, GNUNET_TRANSPORT_IncomingMessage::expected_address_validity, finish_cmc_handling(), free_incoming_request(), GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_eddsa_sign, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcmp, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE, GNUNET_new, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE, GNUNET_YES, GST_cfg, GST_my_private_key, handle_hello_for_incoming(), TransportValidationResponseMessage::header, hello_for_incoming_error_cb(), hello_for_incoming_sync_cb(), CommunicatorMessageContext::im, ir_head, ir_tail, ir_total, lookup_neighbour(), lookup_virtual_link(), MAX_INCOMING_REQUEST, IncomingRequest::nc, IncomingRequest::next, IncomingRequest::pid, GNUNET_CRYPTO_EccSignaturePurpose::purpose, TransportValidationPS::purpose, q, Neighbour::queue_head, TransportValidationResponseMessage::reserved, RMO_ANYTHING_GOES, RMO_REDUNDANT, RMO_UNCONFIRMED_ALLOWED, route_control_message_without_fc(), route_via_neighbour(), GNUNET_TRANSPORT_IncomingMessage::sender, TransportValidationChallengeMessage::sender_time, TransportValidationResponseMessage::signature, GNUNET_MessageHeader::size, start_address_validation(), CommunicatorMessageContext::total_hops, GNUNET_MessageHeader::type, TransportValidationPS::validity_duration, and GNUNET_CRYPTO_ChallengeNonceP::value.

Here is the call graph for this function:

◆ check_known_challenge()

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

Test if the validation state in value matches the challenge from cls.

Parameters
clsa struct CheckKnownChallengeContext
pidunused (must match though)
valuea struct ValidationState
Returns
GNUNET_OK if not matching, GNUNET_NO if match found

Definition at line 9383 of file gnunet-service-transport.c.

9386{
9387 struct CheckKnownChallengeContext *ckac = cls;
9388 struct ValidationState *vs = value;
9389
9390 (void) pid;
9391 if (0 != GNUNET_memcmp (&vs->challenge, ckac->challenge))
9392 return GNUNET_OK;
9393 ckac->vs = vs;
9394 return GNUNET_NO;
9395}
Closure for check_known_challenge.
struct ValidationState * vs
Set to a matching validation state, if one was found.
const struct GNUNET_CRYPTO_ChallengeNonceP * challenge
Set to the challenge we are looking for.

References CheckKnownChallengeContext::challenge, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, pid, value, and CheckKnownChallengeContext::vs.

Referenced by handle_validation_response().

Here is the caller graph for this function:

◆ peerstore_store_validation_cb()

static void peerstore_store_validation_cb ( void *  cls,
int  success 
)
static

Function called when peerstore is done storing a validated address.

Parameters
clsa struct ValidationState
successGNUNET_YES on success

Definition at line 9406 of file gnunet-service-transport.c.

9407{
9408 struct ValidationState *vs = cls;
9409
9410 vs->sc = NULL;
9411 if (GNUNET_YES == success)
9412 return;
9414 "# Peerstore failed to store foreign address",
9415 1,
9416 GNUNET_NO);
9417}

References GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, and GST_stats.

Referenced by handle_validation_response().

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

◆ validation_transmit_on_queue()

static void validation_transmit_on_queue ( struct Queue q,
struct ValidationState vs 
)
static

The queue q (which matches the peer and address in vs) is ready for queueing.

We should now queue the validation request.

Parameters
qqueue to send on
vsstate to derive validation challenge from

Definition at line 11603 of file gnunet-service-transport.c.

11604{
11606 struct GNUNET_TIME_Absolute monotonic_time;
11607
11608 if (NULL != vs->revalidation_task)
11609 {
11610 GNUNET_SCHEDULER_cancel (vs->revalidation_task);
11611 vs->revalidation_task = NULL;
11612 }
11613 /*memcpy (&hkey,
11614 &hc,
11615 sizeof (hkey));*/
11617 "Remove key %s for address %s map size %u contains %u\n",
11618 GNUNET_h2s (&vs->hc),
11619 vs->address,
11622 &vs->hc));
11624
11626 if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
11627 vs->last_challenge_use.abs_value_us)
11628 {
11629 vs->first_challenge_use = monotonic_time;
11630 }
11631 vs->last_challenge_use = monotonic_time;
11632 tvc.header.type =
11634 tvc.header.size = htons (sizeof(tvc));
11635 tvc.reserved = htonl (0);
11636 tvc.challenge = vs->challenge;
11637 tvc.sender_time = GNUNET_TIME_absolute_hton (vs->last_challenge_use);
11639 "Sending address validation challenge %s to %s\n",
11640 GNUNET_sh2s (&tvc.challenge.value),
11641 GNUNET_i2s (&q->neighbour->pid));
11642 queue_send_msg (q, NULL, &tvc, sizeof(tvc));
11643}

References TransportValidationChallengeMessage::challenge, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE, GNUNET_SCHEDULER_cancel(), GNUNET_sh2s(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_UNIT_ZERO_ABS, GST_cfg, TransportValidationChallengeMessage::header, q, queue_send_msg(), TransportValidationChallengeMessage::reserved, revalidation_map, TransportValidationChallengeMessage::sender_time, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, and GNUNET_CRYPTO_ChallengeNonceP::value.

Referenced by check_validation_request_pending(), revalidation_start_cb(), and validation_start_cb().

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

◆ revalidation_start_cb()

static void revalidation_start_cb ( void *  cls)
static

Definition at line 9449 of file gnunet-service-transport.c.

9450{
9451 struct ValidationState *vs = cls;
9452 struct Queue *q;
9453 struct GNUNET_TIME_Absolute now;
9454
9455 vs->revalidation_task = NULL;
9456 q = find_queue (&vs->pid, vs->address);
9457 if (NULL == q)
9458 {
9459 now = GNUNET_TIME_absolute_get ();
9460 vs->awaiting_queue = GNUNET_YES;
9461 suggest_to_connect (&vs->pid, vs->address);
9463 }
9464 else
9466}

References find_queue(), GNUNET_TIME_absolute_get(), GNUNET_YES, ValidationState::pid, q, suggest_to_connect(), update_next_challenge_time(), and validation_transmit_on_queue().

Referenced by handle_validation_response().

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

◆ revalidate_map_it()

static enum GNUNET_GenericReturnValue revalidate_map_it ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 9470 of file gnunet-service-transport.c.

9474{
9475 (void) cls;
9477 "Key in revalidate map %s \n",
9478 GNUNET_h2s (key));
9479 return GNUNET_YES;
9480}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_YES, and key.

Referenced by handle_validation_response().

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

◆ handle_validation_response()

static void handle_validation_response ( void *  cls,
const struct TransportValidationResponseMessage tvr 
)
static

Communicator gave us a transport address validation response.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
tvrthe message that was received

Definition at line 9492 of file gnunet-service-transport.c.

9495{
9496 struct CommunicatorMessageContext *cmc = cls;
9497 struct ValidationState *vs;
9498 struct CheckKnownChallengeContext ckac = { .challenge = &tvr->challenge,
9499 .vs = NULL};
9500 struct GNUNET_TIME_Absolute origin_time;
9501 struct Queue *q;
9502 struct Neighbour *n;
9503 struct VirtualLink *vl;
9505 GST_cfg);
9506
9507 /* check this is one of our challenges */
9509 &cmc->im.sender,
9511 &ckac);
9512 if (NULL == (vs = ckac.vs))
9513 {
9514 /* This can happen simply if we 'forgot' the challenge by now,
9515 i.e. because we received the validation response twice */
9517 "# Validations dropped, challenge unknown",
9518 1,
9519 GNUNET_NO);
9521 "Validation response %s dropped, challenge unknown\n",
9522 GNUNET_sh2s (&tvr->challenge.value));
9523 finish_cmc_handling (cmc);
9524 return;
9525 }
9526
9527 /* sanity check on origin time */
9528 origin_time = GNUNET_TIME_absolute_ntoh (tvr->origin_time);
9529 if ((origin_time.abs_value_us < vs->first_challenge_use.abs_value_us) ||
9530 (origin_time.abs_value_us > vs->last_challenge_use.abs_value_us))
9531 {
9533 "Diff first use %" PRIu64 " and last use %" PRIu64 "\n",
9534 vs->first_challenge_use.abs_value_us - origin_time.abs_value_us,
9535 origin_time.abs_value_us - vs->last_challenge_use.abs_value_us);
9536 GNUNET_break_op (0);
9537 finish_cmc_handling (cmc);
9538 return;
9539 }
9540
9541 {
9542 /* check signature */
9543 struct TransportValidationPS tvp = {
9545 .purpose.size = htonl (sizeof(tvp)),
9546 .validity_duration = tvr->validity_duration,
9547 .challenge = tvr->challenge
9548 };
9549
9550 if (
9551 GNUNET_OK !=
9553 &tvp,
9554 &tvr->signature,
9555 &cmc->im.sender.public_key))
9556 {
9557 GNUNET_break_op (0);
9558 finish_cmc_handling (cmc);
9559 return;
9560 }
9561 }
9562
9563 /* validity is capped by our willingness to keep track of the
9564 validation entry and the maximum the other peer allows */
9567 tvr->validity_duration),
9569 vs->validated_until =
9573 vs->validation_rtt = GNUNET_TIME_absolute_get_duration (origin_time);
9574 vs->challenge_backoff = GNUNET_TIME_UNIT_ZERO;
9576 &vs->challenge,
9577 sizeof(vs->challenge));
9578 vs->first_challenge_use = GNUNET_TIME_absolute_subtract (
9579 vs->validated_until,
9580 GNUNET_TIME_relative_multiply (vs->validation_rtt,
9582 if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, <, now))
9583 {
9585 "First challenge use is now %" PRIu64 " %s \n",
9586 vs->first_challenge_use.abs_value_us,
9587 GNUNET_sh2s (&vs->challenge.value));
9588 vs->first_challenge_use = now;
9589 }
9590 else
9592 "First challenge use is later %" PRIu64 " %s \n",
9593 vs->first_challenge_use.abs_value_us,
9594 GNUNET_sh2s (&vs->challenge.value));
9595 vs->last_challenge_use =
9596 GNUNET_TIME_UNIT_ZERO_ABS; /* challenge was not yet used */
9597 update_next_challenge_time (vs, vs->first_challenge_use);
9599 "Validation response %s from %s accepted, address valid until %s\n",
9600 GNUNET_sh2s (&tvr->challenge.value),
9601 GNUNET_i2s (&cmc->im.sender),
9603 /*memcpy (&hkey,
9604 &hc,
9605 sizeof (hkey));*/
9607 "Key %s for address %s map size %u contains %u\n",
9608 GNUNET_h2s (&vs->hc),
9609 vs->address,
9612 &vs->hc));
9616 &vs->hc,
9617 vs,
9621 NULL);
9622 vs->revalidation_task =
9627 "transport",
9628 &cmc->im.sender,
9630 vs->address,
9631 strlen (vs->address) + 1,
9632 vs->valid_until,
9635 vs);
9636 finish_cmc_handling (cmc);
9637
9638 /* Finally, we now possibly have a confirmed (!) working queue,
9639 update queue status (if queue still is around) */
9640 q = find_queue (&vs->pid, vs->address);
9641 if (NULL == q)
9642 {
9644 "# Queues lost at time of successful validation",
9645 1,
9646 GNUNET_NO);
9647 return;
9648 }
9649 q->validated_until = vs->validated_until;
9650 q->pd.aged_rtt = vs->validation_rtt;
9651 n = q->neighbour;
9652 vl = lookup_virtual_link (&vs->pid);
9653 if (NULL == vl)
9654 {
9655 vl = GNUNET_new (struct VirtualLink);
9657 "Creating new virtual link %p to %s using direct neighbour!\n",
9658 vl,
9659 GNUNET_i2s (&vs->pid));
9660 vl->burst_addr = NULL;
9661 vl->confirmed = GNUNET_YES;
9662 vl->message_uuid_ctr =
9664 vl->target = n->pid;
9670 links,
9671 &vl->target,
9672 vl,
9674 vl->n = n;
9675 n->vl = vl;
9676 q->idle = GNUNET_YES;
9677 vl->visibility_task =
9678 GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
9680 /* We lacked a confirmed connection to the target
9681 before, so tell CORE about it (finally!) */
9684 }
9685 else
9686 {
9687 /* Link was already up, remember n is also now available and we are done */
9688 if (NULL == vl->n)
9689 {
9690 vl->n = n;
9691 n->vl = vl;
9692 if (GNUNET_YES == vl->confirmed)
9694 "Virtual link to %s could now also use direct neighbour!\n",
9695 GNUNET_i2s (&vs->pid));
9696 }
9697 else
9698 {
9699 GNUNET_assert (n == vl->n);
9700 }
9701 if (GNUNET_NO == vl->confirmed)
9702 {
9703 vl->confirmed = GNUNET_YES;
9704 q->idle = GNUNET_YES;
9705 vl->visibility_task =
9706 GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
9708 /* We lacked a confirmed connection to the target
9709 before, so tell CORE about it (finally!) */
9712 }
9713 }
9714}
static void peerstore_store_validation_cb(void *cls, int success)
Function called when peerstore is done storing a validated address.
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.
static void revalidation_start_cb(void *cls)
#define MAX_ADDRESS_VALID_UNTIL
When do we forget an invalid address for sure?
static enum GNUNET_GenericReturnValue revalidate_map_it(void *cls, const struct GNUNET_HashCode *key, void *value)
#define VALIDATION_RTT_BUFFER_FACTOR
How many network RTTs before an address validation expires should we begin trying to revalidate?...
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY
Key used for storing addresses in URL format in the peerstore.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_subtract(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Subtract a given relative duration from the given start time.
Definition: time.c:471
struct GNUNET_CRYPTO_ChallengeNonceP challenge
The challenge that was signed by the receiving peer.
struct GNUNET_CRYPTO_EddsaSignature signature
The peer's signature matching the GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE purpose.

References GNUNET_TIME_Absolute::abs_value_us, ADDRESS_VALIDATION_LIFETIME, VirtualLink::available_fc_window_size, VirtualLink::burst_addr, TransportValidationResponseMessage::challenge, CheckKnownChallengeContext::challenge, check_known_challenge(), check_link_down(), VirtualLink::confirmed, consider_sending_fc(), VirtualLink::core_recv_window, cores_send_connect_info(), DEFAULT_WINDOW_SIZE, find_queue(), finish_cmc_handling(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_eddsa_verify, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_block(), GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_STOREOPTION_MULTIPLE, GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY, GNUNET_SCHEDULER_add_at(), GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE, GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_min(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_absolute_subtract(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_ntoh(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_MINUTES, GNUNET_TIME_UNIT_ZERO, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, GST_cfg, GST_stats, CommunicatorMessageContext::im, VirtualLink::incoming_fc_window_size, links, lookup_virtual_link(), MAX_ADDRESS_VALID_UNTIL, VirtualLink::message_uuid_ctr, VirtualLink::n, peerstore, peerstore_store_validation_cb(), Neighbour::pid, ValidationState::pid, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, TransportValidationPS::purpose, q, RECV_WINDOW_SIZE, revalidate_map_it(), revalidation_map, revalidation_start_cb(), send_msg_from_cache(), GNUNET_TRANSPORT_IncomingMessage::sender, TransportValidationResponseMessage::signature, VirtualLink::target, update_next_challenge_time(), ValidationState::valid_until, ValidationState::validated_until, validation_map, VALIDATION_RTT_BUFFER_FACTOR, GNUNET_CRYPTO_ChallengeNonceP::value, VirtualLink::visibility_task, Neighbour::vl, and CheckKnownChallengeContext::vs.

Here is the call graph for this function:

◆ handle_incoming_msg()

static void handle_incoming_msg ( void *  cls,
const struct GNUNET_TRANSPORT_IncomingMessage im 
)
static

Incoming message.

Process the request.

Parameters
imthe send message that was received

Definition at line 9723 of file gnunet-service-transport.c.

9725{
9726 struct TransportClient *tc = cls;
9727 struct CommunicatorMessageContext *cmc =
9729
9730 cmc->tc = tc;
9731 cmc->im = *im;
9733 "Received message with size %u and flow control id %" PRIu64
9734 " via communicator from peer %s\n",
9735 ntohs (im->header.size),
9736 im->fc_id,
9737 GNUNET_i2s (&im->sender));
9738 cmc->im.neighbour_sender = cmc->im.sender;
9739 cmc->mh = (const struct GNUNET_MessageHeader *) &im[1];
9741}
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG.
Definition: transport.h:337

References demultiplex_with_cmc(), GNUNET_TRANSPORT_IncomingMessage::fc_id, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_TRANSPORT_IncomingMessage::header, CommunicatorMessageContext::im, CommunicatorMessageContext::mh, GNUNET_TRANSPORT_IncomingMessage::neighbour_sender, GNUNET_TRANSPORT_IncomingMessage::sender, GNUNET_MessageHeader::size, tc, and CommunicatorMessageContext::tc.

Here is the call graph for this function:

◆ check_flow_control()

static int check_flow_control ( void *  cls,
const struct TransportFlowControlMessage fc 
)
static

Communicator gave us a transport address validation response.

Check the request.

Parameters
clsa struct CommunicatorMessageContext
fcthe message that was received
Returns
GNUNET_YES if message is well-formed

Definition at line 9753 of file gnunet-service-transport.c.

9754{
9755 unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
9756 (void) cls;
9757
9759 "Flow control header size %u size of addresses %u number of addresses %u size of message struct %lu second struct %lu\n",
9760 ntohs (fc->header.size),
9761 ntohl (fc->size_of_addresses),
9762 ntohl (fc->number_of_addresses),
9763 sizeof(struct TransportFlowControlMessage),
9764 sizeof (struct TransportGlobalNattedAddress));
9765
9766 if (0 == number_of_addresses || ntohs (fc->header.size) == sizeof(struct
9768 + ntohl (fc->number_of_addresses) * sizeof (struct
9770 + ntohl (fc->size_of_addresses))
9771 return GNUNET_OK;
9772 else
9773 {
9774 GNUNET_break_op (0);
9775 return GNUNET_SYSERR;
9776 }
9777}

References GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, TransportFlowControlMessage::header, TransportFlowControlMessage::number_of_addresses, GNUNET_MessageHeader::size, and TransportFlowControlMessage::size_of_addresses.

◆ iterate_address_start_burst()

static void iterate_address_start_burst ( void *  cls,
const struct GNUNET_PeerIdentity pid,
const char *  uri 
)
static

Definition at line 9808 of file gnunet-service-transport.c.

9811{
9812 struct VirtualLink *vl = cls;
9813 const char *slash;
9814 char *address_uri;
9815 char *prefix;
9816 char *uri_without_port;
9817
9818 slash = strrchr (uri, '/');
9819 prefix = GNUNET_strndup (uri, (slash - uri) - 2);
9820 GNUNET_assert (NULL != slash);
9821 slash++;
9822 GNUNET_asprintf (&address_uri,
9823 "%s-%s",
9824 prefix,
9825 slash);
9826
9827 uri_without_port = get_address_without_port (address_uri);
9829 "iterate_address_start_burst %s %s %s %s\n",
9830 uri_without_port,
9831 uri,
9832 address_uri,
9833 slash);
9834 if (0 == strcmp (uri_without_port, slash))
9835 {
9836 vl->burst_addr = GNUNET_strndup (uri_without_port, strlen (uri_without_port)
9837 );
9838 }
9839 else
9840 vl->burst_addr = NULL;
9841
9843 GNUNET_free (uri_without_port);
9844}

References VirtualLink::burst_addr, get_address_without_port(), GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_strndup, prefix, and uri.

Referenced by check_for_burst_address().

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

◆ check_for_burst_address()

static void check_for_burst_address ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Definition at line 9848 of file gnunet-service-transport.c.

9851{
9852 struct GNUNET_StartBurstCls *sb_cls = cls;
9853 struct VirtualLink *vl = sb_cls->vl;
9854 struct GNUNET_MessageHeader *hello;
9856
9857 if (NULL != emsg)
9858 {
9860 "Got failure from PEERSTORE: %s\n",
9861 emsg);
9862 return;
9863 }
9864 if (NULL == record)
9865 {
9867 "Hello iteration end for %s\n",
9868 GNUNET_i2s (&vl->target));
9869 vl->ic = NULL;
9870 GNUNET_free (sb_cls);
9871 return;
9872 }
9873
9875 "check_for_burst_address\n");
9876 hello = record->value;
9880 vl);
9882
9884 GNUNET_free (sb_cls);
9885}
static void iterate_address_start_burst(void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
Struct wrapping information we use for starting the burst.
struct VirtualLink * vl
The VirtualLink of the peer to which we like to burst with.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_iterate(), GNUNET_i2s(), GNUNET_log, GNUNET_PEERSTORE_iteration_stop(), VirtualLink::ic, iterate_address_start_burst(), consensus-simulation::parser, record(), VirtualLink::sb_cls, VirtualLink::target, and GNUNET_StartBurstCls::vl.

Referenced by queue_burst().

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

◆ burst_timeout()

static void burst_timeout ( void *  cls)
static

Definition at line 9889 of file gnunet-service-transport.c.

9890{
9892}
static enum GNUNET_GenericReturnValue burst_running
Is there a burst running?

References burst_running, and GNUNET_NO.

Referenced by start_burst().

Here is the caller graph for this function:

◆ start_burst()

static void start_burst ( void *  cls)
static

Definition at line 9896 of file gnunet-service-transport.c.

9897{
9898 struct GNUNET_StartBurstCls *sb_cls = cls;
9899 struct VirtualLink *vl = sb_cls->vl;
9900 struct GNUNET_TRANSPORT_StartBurst *sb;
9901 struct GNUNET_MQ_Envelope *env;
9902 char *uri_without_port = vl->burst_addr;
9903
9904 burst_task = NULL;
9905 /*char buf[strlen (uri_without_port) + 1];
9906
9907 GNUNET_memcpy (buf, uri_without_port, strlen (uri_without_port));
9908 buf[strlen (uri_without_port)] = '\0';*/
9909 env =
9911 strlen (uri_without_port) + 1,
9913 sb->rtt = GNUNET_TIME_relative_hton (sb_cls->rtt);
9914 sb->pid = vl->target;
9915 memcpy (&sb[1], uri_without_port, strlen (uri_without_port) + 1);
9916 for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
9917 {
9919 "iterate_address_start_burst client tc prefix %s\n",
9920 tc->details.communicator.address_prefix);
9921 if (CT_COMMUNICATOR != tc->type)
9922 continue;
9923 if (GNUNET_YES == tc->details.communicator.can_burst)
9924 {
9926 "iterate_address_start_burst %s call %lu %u rtt %lu\n",
9927 uri_without_port,
9928 strlen (uri_without_port),
9929 ntohs (sb->header.size),
9930 (unsigned long) sb_cls->rtt.rel_value_us);
9931 GNUNET_MQ_send (tc->mq, env);
9935 60),
9937 NULL);
9938 // TODO We need some algo to choose from available communicators. Can we run two bursts at once? Atm we only implemented udp burst.
9939 break;
9940 }
9941 }
9942 GNUNET_free (env);
9943 GNUNET_free (sb_cls);
9944}
static void burst_timeout(void *cls)
struct GNUNET_SCHEDULER_Task * burst_timeout_task
static struct GNUNET_SCHEDULER_Task * burst_task
The task to start the burst.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST
Burst message we send to another peer for hole punching.
struct GNUNET_TIME_Relative rtt
The average RTT between the peers.
Message from transport to communicator to start a burst.
Definition: transport.h:680
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST.
Definition: transport.h:684
struct GNUNET_TIME_RelativeNBO rtt
Definition: transport.h:691
struct GNUNET_PeerIdentity pid
Target peer.
Definition: transport.h:689

References VirtualLink::burst_addr, burst_running, burst_task, burst_timeout(), burst_timeout_task, clients_head, CT_COMMUNICATOR, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, GNUNET_TRANSPORT_StartBurst::header, GNUNET_TRANSPORT_StartBurst::pid, GNUNET_TIME_Relative::rel_value_us, GNUNET_StartBurstCls::rtt, GNUNET_TRANSPORT_StartBurst::rtt, VirtualLink::sb_cls, GNUNET_MessageHeader::size, VirtualLink::target, tc, and GNUNET_StartBurstCls::vl.

Referenced by queue_burst().

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

◆ queue_burst()

static void queue_burst ( void *  cls)
static

Definition at line 9948 of file gnunet-service-transport.c.

9949{
9950 struct GNUNET_StartBurstCls *sb_cls = cls;
9951 struct VirtualLink *vl = sb_cls->vl;
9952
9953 if (GNUNET_YES != use_burst)
9954 return;
9956 "burst_task %p ready %s burst addr %s (%p)\n",
9957 burst_task,
9958 sb_cls->sync_ready ? "yes" : "no",
9959 vl->burst_addr,
9960 vl->burst_addr);
9961 if (NULL != burst_task && GNUNET_NO == sb_cls->sync_ready)
9962 {
9964 burst_task = NULL;
9966 return;
9967 }
9968 if (GNUNET_NO == burst_running && NULL != vl->burst_addr && NULL == burst_task
9969 )
9970 {
9972 &start_burst,
9973 sb_cls);
9974 }
9975 else if (NULL == vl->burst_addr)
9976 {
9978 "peerstore",
9979 &vl->target,
9982 sb_cls);
9983 }
9984}
static void start_burst(void *cls)
static void check_for_burst_address(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
enum GNUNET_GenericReturnValue use_burst
struct GNUNET_TIME_Relative delay
The delay - calculate from the RTT and which peer was ready to sync first, after we will start the bu...
unsigned int sync_ready
We are ready to start the burst.

References VirtualLink::burst_addr, burst_running, burst_task, check_for_burst_address(), GNUNET_StartBurstCls::delay, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_iteration_start(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, VirtualLink::ic, peerstore, VirtualLink::sb_cls, start_burst(), GNUNET_StartBurstCls::sync_ready, VirtualLink::target, use_burst, and GNUNET_StartBurstCls::vl.

Referenced by handle_flow_control().

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

◆ handle_flow_control()

static void handle_flow_control ( void *  cls,
const struct TransportFlowControlMessage fc 
)
static

Communicator gave us a transport address validation response.

Process the request.

Parameters
clsa struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
fcthe message that was received

Definition at line 9996 of file gnunet-service-transport.c.

9997{
9998 struct CommunicatorMessageContext *cmc = cls;
9999 struct VirtualLink *vl;
10001 uint32_t seq;
10002 struct GNUNET_TIME_Absolute st;
10003 uint64_t os;
10004 uint64_t wnd;
10005 uint32_t random;
10006
10008 "Received FC from %s\n", GNUNET_i2s (&cmc->im.sender));
10009 vl = lookup_virtual_link (&cmc->im.sender);
10010 if (NULL == vl)
10011 {
10012 vl = GNUNET_new (struct VirtualLink);
10014 "No virtual link for %p FC creating new unconfirmed virtual link to %s!\n",
10015 vl,
10016 GNUNET_i2s (&cmc->im.sender));
10017 vl->burst_addr = NULL;
10018 vl->confirmed = GNUNET_NO;
10019 vl->message_uuid_ctr =
10021 vl->target = cmc->im.sender;
10027 links,
10028 &vl->target,
10029 vl,
10031 }
10032 if (NULL != vl->n)
10033 {
10034 for (struct Queue *q = vl->n->queue_head; NULL != q; q = q->next_neighbour)
10035 q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
10036 }
10037
10039 "remaining %lu timeout for neighbour %p\n",
10040 (unsigned long) GNUNET_TIME_absolute_get_remaining (q_timeout).
10041 rel_value_us,
10042 vl->n);
10043 if (NULL == vl->n ||
10044 0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
10045 {
10046 struct GNUNET_TIME_Relative rtt;
10047 struct GNUNET_BurstSync burst_sync;
10048 struct GNUNET_StartBurstCls *bcls;
10049
10050 bcls = GNUNET_new (struct GNUNET_StartBurstCls);
10051 bcls->vl = vl;
10052 vl->sb_cls = bcls;
10053 if (NULL != vl->dv)
10054 rtt = calculate_rtt (vl->dv);
10055 else
10057 burst_sync.rtt_average = fc->rtt;
10058 bcls->rtt = GNUNET_TIME_relative_ntoh (burst_sync.rtt_average);
10059 burst_sync.sync_ready = fc->sync_ready;
10060
10062 &burst_sync,
10063 &queue_burst,
10064 bcls);
10065 }
10066 if (0 != ntohl (fc->number_of_addresses))
10067 {
10068 unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
10069 const char *tgnas;
10070 unsigned int off = 0;
10071
10072 tgnas = (const char *) &fc[1];
10073
10074 for (int i = 1; i <= number_of_addresses; i++)
10075 {
10076 struct TransportGlobalNattedAddress *tgna;
10077 char *addr;
10078 unsigned int address_length;
10079
10080 tgna = (struct TransportGlobalNattedAddress*) &tgnas[off];
10081 addr = (char *) &tgna[1];
10082 address_length = ntohl (tgna->address_length);
10083 off += sizeof(struct TransportGlobalNattedAddress) + address_length;
10084
10086 "received address %s length %u\n",
10087 addr,
10088 ntohl (tgna->address_length));
10089
10090 GNUNET_NAT_add_global_address (nh, addr, ntohl (tgna->address_length));
10091 }
10092 }
10094 if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us)
10095 {
10097 "FC dropped: Message out of order\n");
10098 /* out of order, drop */
10100 "# FC dropped: message out of order",
10101 1,
10102 GNUNET_NO);
10103 finish_cmc_handling (cmc);
10104 return;
10105 }
10106 seq = ntohl (fc->seq);
10107 if (seq < vl->last_fc_seq)
10108 {
10109 /* Wrap-around/reset of other peer; start all counters from zero */
10111 }
10112 vl->last_fc_seq = seq;
10113 vl->last_fc_timestamp = st;
10117 (int64_t) (os - vl->incoming_fc_window_size_used);
10119 "Received FC from %s, seq %u, new window %llu (loss at %lld)\n",
10120 GNUNET_i2s (&vl->target),
10121 (unsigned int) seq,
10122 (unsigned long long) vl->outbound_fc_window_size,
10123 (long long) vl->incoming_fc_window_size_loss);
10126 UINT32_MAX);
10127 if ((GNUNET_YES == vl->confirmed) && ((wnd < vl->incoming_fc_window_size
10131 != wnd) ||
10132 (0 == random
10134 {
10136 "Consider re-sending our FC message, as clearly the other peer's idea of the window is not up-to-date (%llu vs %llu) or %llu last received differs, or random reply %u\n",
10137 (unsigned long long) wnd,
10138 (unsigned long long) vl->incoming_fc_window_size,
10139 (unsigned long long) vl->last_outbound_window_size_received,
10142 }
10143 if ((wnd == vl->incoming_fc_window_size
10147 (NULL != vl->fc_retransmit_task))
10148 {
10150 "Stopping FC retransmission to %s: peer is current at window %llu\n",
10151 GNUNET_i2s (&vl->target),
10152 (unsigned long long) wnd);
10154 vl->fc_retransmit_task = NULL;
10155 vl->fc_retransmit_count = 0;
10156 }
10158 /* FC window likely increased, check transmission possibilities! */
10160 finish_cmc_handling (cmc);
10161}
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
static ogg_stream_state os
Ogg stream state.
static void queue_burst(void *cls)
#define FC_NO_CHANGE_REPLY_PROBABILITY
What is the 1:n chance that we send a Flow control response when receiving a flow control message tha...
void GNUNET_is_burst_ready(struct GNUNET_TIME_Relative rtt_average, struct GNUNET_BurstSync *burst_sync, GNUNET_SCHEDULER_TaskCallback task, struct GNUNET_StartBurstCls *task_cls)
Checks if we are ready and starts burst when we and the other peer is ready.
Definition: nat.c:89
void GNUNET_NAT_add_global_address(struct GNUNET_NAT_Handle *nh, char *addr, unsigned int address_length)
Add global address to the list of addresses and notify clients.
Definition: nat_api.c:460
Wrapper struct with the average RTT of message to some peer and if this peer und us is ready to sync.

References GNUNET_TIME_Absolute::abs_value_us, TransportGlobalNattedAddress::address_length, VirtualLink::available_fc_window_size, VirtualLink::burst_addr, calculate_rtt(), check_vl_transmission(), VirtualLink::confirmed, consider_sending_fc(), VirtualLink::core_recv_window, DEFAULT_WINDOW_SIZE, VirtualLink::dv, FC_NO_CHANGE_REPLY_PROBABILITY, VirtualLink::fc_retransmit_count, VirtualLink::fc_retransmit_task, finish_cmc_handling(), GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_is_burst_ready(), GNUNET_log, GNUNET_NAT_add_global_address(), GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_max(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_ntoh(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, GST_stats, CommunicatorMessageContext::im, TransportFlowControlMessage::inbound_window_size, VirtualLink::incoming_fc_window_size, VirtualLink::incoming_fc_window_size_loss, VirtualLink::incoming_fc_window_size_used, VirtualLink::last_fc_seq, VirtualLink::last_fc_timestamp, VirtualLink::last_outbound_window_size_received, links, lookup_virtual_link(), VirtualLink::message_uuid_ctr, VirtualLink::n, nh, TransportFlowControlMessage::number_of_addresses, os, VirtualLink::outbound_fc_window_size, VirtualLink::outbound_fc_window_size_used, TransportFlowControlMessage::outbound_sent, TransportFlowControlMessage::outbound_window_size, q, queue_burst(), Neighbour::queue_head, RECV_WINDOW_SIZE, GNUNET_StartBurstCls::rtt, TransportFlowControlMessage::rtt, GNUNET_BurstSync::rtt_average, VirtualLink::sb_cls, GNUNET_TRANSPORT_IncomingMessage::sender, TransportFlowControlMessage::sender_time, TransportFlowControlMessage::seq, st, GNUNET_BurstSync::sync_ready, TransportFlowControlMessage::sync_ready, VirtualLink::target, and GNUNET_StartBurstCls::vl.

Here is the call graph for this function:

◆ check_add_queue_message()

static int check_add_queue_message ( void *  cls,
const struct GNUNET_TRANSPORT_AddQueueMessage aqm 
)
static

New queue became available.

Check message.

Parameters
clsthe client
aqmthe send message that was sent

Definition at line 10244 of file gnunet-service-transport.c.

10246{
10247 struct TransportClient *tc = cls;
10248
10249 if (CT_COMMUNICATOR != tc->type)
10250 {
10251 GNUNET_break (0);
10252 return GNUNET_SYSERR;
10253 }
10255 return GNUNET_OK;
10256}

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

◆ set_pending_message_uuid()

static void set_pending_message_uuid ( struct PendingMessage pm)
static

If necessary, generates the UUID for a pm.

Parameters
pmpending message to generate UUID for.

Definition at line 10265 of file gnunet-service-transport.c.

10266{
10267 if (pm->msg_uuid_set)
10268 return;
10269 pm->msg_uuid.uuid = pm->vl->message_uuid_ctr++;
10270 pm->msg_uuid_set = GNUNET_YES;
10271}

References GNUNET_YES, and pm.

Referenced by extract_box_cb(), fragment_message(), and reliability_box_message().

Here is the caller graph for this function:

◆ prepare_pending_acknowledgement()

static struct PendingAcknowledgement * prepare_pending_acknowledgement ( struct Queue queue,
struct DistanceVectorHop dvh,
struct PendingMessage pm 
)
static

Setup data structure waiting for acknowledgements.

Parameters
queuequeue the pm will be sent over
dvhpath the message will take, may be NULL
pmthe pending message for transmission
Returns
corresponding fresh pending acknowledgement

Definition at line 10283 of file gnunet-service-transport.c.

10286{
10287 struct PendingAcknowledgement *pa;
10288
10289 pa = GNUNET_new (struct PendingAcknowledgement);
10290 pa->queue = queue;
10291 pa->dvh = dvh;
10292 pa->pm = pm;
10293 do
10294 {
10296 &pa->ack_uuid,
10297 sizeof(pa->ack_uuid));
10298 }
10301 &pa->ack_uuid.value,
10302 pa,
10304 GNUNET_CONTAINER_MDLL_insert (queue, queue->pa_head, queue->pa_tail, pa);
10305 GNUNET_CONTAINER_MDLL_insert (pm, pm->pa_head, pm->pa_tail, pa);
10306 if (NULL != dvh)
10309 pa->message_size = pm->bytes_msg;
10311 "Waiting for ACKnowledgment `%s' for <%" PRIu64 ">\n",
10313 pm->logging_uuid);
10314 return pa;
10315}
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multiuuidmap_put(struct GNUNET_CONTAINER_MultiUuidmap *map, const struct GNUNET_Uuid *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.

References PendingAcknowledgement::ack_uuid, PendingAcknowledgement::dvh, GNUNET_CONTAINER_MDLL_insert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multiuuidmap_put(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_block(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_uuid2s(), GNUNET_YES, PendingAcknowledgement::message_size, DistanceVectorHop::pa_head, DistanceVectorHop::pa_tail, pending_acks, PendingAcknowledgement::pm, pm, queue(), PendingAcknowledgement::queue, PendingAcknowledgement::transmission_time, and AcknowledgementUUIDP::value.

Referenced by fragment_message(), and reliability_box_message().

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

◆ fragment_message()

static struct PendingMessage * fragment_message ( struct Queue queue,
struct DistanceVectorHop dvh,
struct PendingMessage pm 
)
static

Fragment the given pm to the given mtu.

Adds additional fragments to the neighbour as well. If the mtu is too small, generates and error for the pm and returns NULL.

Parameters
queuewhich queue to fragment for
dvhpath the message will take, or NULL
pmpending message to fragment for transmission
Returns
new message to transmit

Definition at line 10330 of file gnunet-service-transport.c.

10333{
10334 struct PendingAcknowledgement *pa;
10335 struct PendingMessage *ff;
10336 uint16_t mtu;
10337 uint16_t msize;
10338
10339 mtu = (UINT16_MAX == queue->mtu)
10340 ? UINT16_MAX - sizeof(struct GNUNET_TRANSPORT_SendMessageTo)
10341 : queue->mtu;
10343 "Fragmenting message <%" PRIu64
10344 "> with size %u to %s for MTU %u\n",
10345 pm->logging_uuid,
10346 pm->bytes_msg,
10347 GNUNET_i2s (&pm->vl->target),
10348 (unsigned int) mtu);
10351 "Fragmenting message %" PRIu64 " <%" PRIu64
10352 "> with size %u to %s for MTU %u\n",
10353 pm->msg_uuid.uuid,
10354 pm->logging_uuid,
10355 pm->bytes_msg,
10356 GNUNET_i2s (&pm->vl->target),
10357 (unsigned int) mtu);
10358
10359 /* This invariant is established in #handle_add_queue_message() */
10360 GNUNET_assert (mtu > sizeof(struct TransportFragmentBoxMessage));
10361
10362 /* select fragment for transmission, descending the tree if it has
10363 been expanded until we are at a leaf or at a fragment that is small
10364 enough
10365 */
10366 ff = pm;
10367 msize = ff->bytes_msg;
10368
10369 while (((ff->bytes_msg > mtu) || (pm == ff)) &&
10370 (ff->frag_off == msize) && (NULL != ff->head_frag))
10371 {
10372 ff = ff->head_frag; /* descent into fragmented fragments */
10373 msize = ff->bytes_msg - sizeof(struct TransportFragmentBoxMessage);
10374 }
10375
10376 if (((ff->bytes_msg > mtu) || (pm == ff)) && (ff->frag_off < msize))
10377 {
10378 /* Did not yet calculate all fragments, calculate next fragment */
10379 struct PendingMessage *frag;
10380 struct TransportFragmentBoxMessage tfb;
10381 const char *orig;
10382 char *msg;
10383 uint16_t fragmax;
10384 uint16_t fragsize;
10385 uint16_t msize_ff;
10386 uint16_t xoff = 0;
10387 pm->frag_count++;
10388
10389 orig = (const char *) &ff[1];
10390 msize_ff = ff->bytes_msg;
10391 if (pm != ff)
10392 {
10393 const struct TransportFragmentBoxMessage *tfbo;
10394
10395 tfbo = (const struct TransportFragmentBoxMessage *) orig;
10396 orig += sizeof(struct TransportFragmentBoxMessage);
10397 msize_ff -= sizeof(struct TransportFragmentBoxMessage);
10398 xoff = ntohs (tfbo->frag_off);
10399 }
10400 fragmax = mtu - sizeof(struct TransportFragmentBoxMessage);
10401 fragsize = GNUNET_MIN (msize_ff - ff->frag_off, fragmax);
10402 frag =
10403 GNUNET_malloc (sizeof(struct PendingMessage)
10404 + sizeof(struct TransportFragmentBoxMessage) + fragsize);
10406 "3 created pm %p from pm %p storing vl %p from pm %p\n",
10407 frag,
10408 ff,
10409 pm->vl,
10410 pm);
10412 frag->vl = pm->vl;
10413 frag->frag_parent = ff;
10414 frag->timeout = pm->timeout;
10415 frag->bytes_msg = sizeof(struct TransportFragmentBoxMessage) + fragsize;
10416 frag->pmt = PMT_FRAGMENT_BOX;
10417 msg = (char *) &frag[1];
10418 tfb.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT);
10419 tfb.header.size =
10420 htons (sizeof(struct TransportFragmentBoxMessage) + fragsize);
10421 pa = prepare_pending_acknowledgement (queue, dvh, frag);
10422 tfb.ack_uuid = pa->ack_uuid;
10423 tfb.msg_uuid = pm->msg_uuid;
10424 tfb.frag_off = htons (ff->frag_off + xoff);
10425 tfb.msg_size = htons (pm->bytes_msg);
10426 memcpy (msg, &tfb, sizeof(tfb));
10427 memcpy (&msg[sizeof(tfb)], &orig[ff->frag_off], fragsize);
10429 ff->tail_frag, frag);
10430 ff->frag_off += fragsize;
10431 ff = frag;
10432 }
10433
10434 /* Move head to the tail and return it */
10438 ff);
10442 ff);
10443
10444 return ff;
10445}
static struct PendingAcknowledgement * prepare_pending_acknowledgement(struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
Setup data structure waiting for acknowledgements.
static void set_pending_message_uuid(struct PendingMessage *pm)
If necessary, generates the UUID for a pm.
#define GNUNET_CONTAINER_MDLL_insert_tail(mdll, head, tail, element)
Insert an element at the tail of a MDLL.
uint64_t logging_uuid
UUID we use to identify this message in our logs.
struct GNUNET_TIME_Absolute timeout
At what time should we give up on the transmission (and no longer retry)?

References TransportFragmentBoxMessage::ack_uuid, PendingAcknowledgement::ack_uuid, PendingMessage::bytes_msg, TransportFragmentBoxMessage::frag_off, PendingMessage::frag_off, PendingMessage::frag_parent, GNUNET_assert, GNUNET_CONTAINER_MDLL_insert, GNUNET_CONTAINER_MDLL_insert_tail, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT, GNUNET_MIN, PendingMessage::head_frag, TransportFragmentBoxMessage::header, PendingMessage::logging_uuid, logging_uuid_gen, msg, TransportFragmentBoxMessage::msg_size, TransportFragmentBoxMessage::msg_uuid, pm, PendingMessage::pmt, PMT_FRAGMENT_BOX, prepare_pending_acknowledgement(), queue(), set_pending_message_uuid(), GNUNET_MessageHeader::size, PendingMessage::tail_frag, PendingMessage::timeout, GNUNET_MessageHeader::type, and PendingMessage::vl.

Referenced by transmit_on_queue().

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

◆ reliability_box_message()

static struct PendingMessage * reliability_box_message ( struct Queue queue,
struct DistanceVectorHop dvh,
struct PendingMessage pm 
)
static

Reliability-box the given pm.

On error (can there be any), NULL may be returned, otherwise the "replacement" for pm (which should then be added to the respective neighbour's queue instead of pm). If the pm is already fragmented or reliability boxed, or itself an ACK, this function simply returns pm.

Parameters
queuewhich queue to prepare transmission for
dvhpath the message will take, or NULL
pmpending message to box for transmission over unreliabile queue
Returns
new message to transmit

Definition at line 10461 of file gnunet-service-transport.c.

10464{
10466 struct PendingAcknowledgement *pa;
10467 struct PendingMessage *bpm;
10468 char *msg;
10469
10470 if ((PMT_CORE != pm->pmt) && (PMT_DV_BOX != pm->pmt))
10471 return pm; /* already fragmented or reliability boxed, or control message:
10472 do nothing */
10473 if (NULL != pm->bpm)
10474 return pm->bpm; /* already computed earlier: do nothing */
10475 // TODO I guess we do not need this assertion. We might have a DLL with
10476 // fragments, because the MTU changed, and we do not need to fragment anymore.
10477 // But we should keep the fragments until message was completed, because
10478 // the MTU might change again.
10479 // GNUNET_assert (NULL == pm->head_frag);
10480 if (pm->bytes_msg + sizeof(rbox) > UINT16_MAX)
10481 {
10482 /* failed hard */
10483 GNUNET_break (0);
10485 return NULL;
10486 }
10487
10489
10490 bpm = GNUNET_malloc (sizeof(struct PendingMessage) + sizeof(rbox)
10491 + pm->bytes_msg);
10493 "4 created pm %p storing vl %p from pm %p\n",
10494 bpm,
10495 pm->vl,
10496 pm);
10498 bpm->vl = pm->vl;
10499 bpm->frag_parent = pm;
10500 // Why was this needed?
10501 // GNUNET_CONTAINER_MDLL_insert (frag, pm->head_frag, pm->tail_frag, bpm);
10502 bpm->timeout = pm->timeout;
10504 bpm->bytes_msg = pm->bytes_msg + sizeof(rbox);
10506 rbox.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX);
10507 rbox.header.size = htons (sizeof(rbox) + pm->bytes_msg);
10508 rbox.ack_countdown = htonl (0); // FIXME: implement ACK countdown support
10509
10510 rbox.ack_uuid = pa->ack_uuid;
10511 msg = (char *) &bpm[1];
10512 memcpy (msg, &rbox, sizeof(rbox));
10513 memcpy (&msg[sizeof(rbox)], &pm[1], pm->bytes_msg);
10514 pm->bpm = bpm;
10516 "Preparing reliability box for message <%" PRIu64
10517 "> of size %d (%d) to %s on queue %s\n",
10518 pm->logging_uuid,
10519 pm->bytes_msg,
10520 ntohs (((const struct GNUNET_MessageHeader *) &pm[1])->size),
10521 GNUNET_i2s (&pm->vl->target),
10522 queue->address);
10523 return bpm;
10524}

References TransportReliabilityBoxMessage::ack_countdown, TransportReliabilityBoxMessage::ack_uuid, PendingAcknowledgement::ack_uuid, PendingMessage::bpm, PendingMessage::bytes_msg, client_send_response(), PendingMessage::frag_parent, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX, TransportReliabilityBoxMessage::header, PendingMessage::logging_uuid, logging_uuid_gen, msg, pm, PendingMessage::pmt, PMT_CORE, PMT_DV_BOX, PMT_RELIABILITY_BOX, prepare_pending_acknowledgement(), queue(), set_pending_message_uuid(), GNUNET_MessageHeader::size, size, PendingMessage::timeout, GNUNET_MessageHeader::type, and PendingMessage::vl.

Referenced by transmit_on_queue().

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

◆ reorder_root_pm()

static void reorder_root_pm ( struct PendingMessage pm,
struct GNUNET_TIME_Absolute  next_attempt 
)
static

Definition at line 10528 of file gnunet-service-transport.c.

10530{
10531 struct VirtualLink *vl = pm->vl;
10532 struct PendingMessage *pos;
10533
10534 /* re-insert sort in neighbour list */
10538 pm);
10539 pos = vl->pending_msg_tail;
10540 while ((NULL != pos) &&
10542 pos = pos->prev_vl;
10546 pos,
10547 pm);
10548}
#define GNUNET_CONTAINER_MDLL_insert_after(mdll, head, tail, other, element)
Insert an element into a MDLL after the given other element.
struct PendingMessage * prev_vl
Kept in a MDLL of messages for this vl.
struct GNUNET_TIME_Absolute next_attempt
What is the earliest time for us to retry transmission of this message?

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONTAINER_MDLL_insert_after, GNUNET_CONTAINER_MDLL_remove, PendingMessage::next_attempt, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, pm, PendingMessage::prev_vl, and PendingMessage::vl.

Referenced by update_pm_next_attempt().

Here is the caller graph for this function:

◆ check_next_attempt_tree()

static unsigned int check_next_attempt_tree ( struct PendingMessage pm,
struct PendingMessage root 
)
static

Definition at line 10552 of file gnunet-service-transport.c.

10553{
10554 struct PendingMessage *pos;
10556
10557 pos = pm->head_frag;
10558 while (NULL != pos)
10559 {
10560 if (pos->frags_in_flight_round == pm->frags_in_flight_round ||
10561 GNUNET_NO == check_next_attempt_tree (pos, root))
10563 else
10564 {
10566 break;
10567 }
10568 pos = pos->next_frag;
10569 }
10570
10571 return frags_in_flight;
10572}
static unsigned int check_next_attempt_tree(struct PendingMessage *pm, struct PendingMessage *root)
GNUNET_GenericReturnValue
Named constants for return values.
uint32_t frags_in_flight_round
The round we are (re)-sending fragments.
uint32_t frags_in_flight
Are we sending fragments at the moment?
struct PendingMessage * next_frag
Kept in a MDLL of messages from this cpm (if pmt is #PMT_FRAGMENT_BOx)

References check_next_attempt_tree(), PendingMessage::frags_in_flight, PendingMessage::frags_in_flight_round, GNUNET_NO, GNUNET_YES, PendingMessage::next_frag, and pm.

Referenced by check_next_attempt_tree(), and update_pm_next_attempt().

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

◆ harmonize_flight_round()

static void harmonize_flight_round ( struct PendingMessage pm)
static

Definition at line 10576 of file gnunet-service-transport.c.

10577{
10578 struct PendingMessage *pos;
10579
10580 pos = pm->head_frag;
10581 while (NULL != pos)
10582 {
10583 pos->frags_in_flight_round = pm->frags_in_flight_round;
10585 pos = pos->next_frag;
10586 }
10587}
static void harmonize_flight_round(struct PendingMessage *pm)

References PendingMessage::frags_in_flight_round, harmonize_flight_round(), PendingMessage::next_frag, and pm.

Referenced by harmonize_flight_round(), and update_pm_next_attempt().

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

◆ update_pm_next_attempt()

static void update_pm_next_attempt ( struct PendingMessage pm,
struct GNUNET_TIME_Absolute  next_attempt 
)
static

Change the value of the next_attempt field of pm to next_attempt and re-order pm in the transmission list as required by the new timestamp.

Parameters
pma pending message to update
next_attempttimestamp to use

Definition at line 10599 of file gnunet-service-transport.c.

10601{
10602 if (NULL == pm->frag_parent)
10603 {
10604 pm->next_attempt = next_attempt;
10606 "Next attempt for message <%" PRIu64 "> set to %" PRIu64 "\n",
10607 pm->logging_uuid,
10608 next_attempt.abs_value_us);
10609 reorder_root_pm (pm, next_attempt);
10610 }
10611 else if ((PMT_RELIABILITY_BOX == pm->pmt) || (PMT_DV_BOX == pm->pmt))// || (PMT_FRAGMENT_BOX == pm->pmt))
10612 {
10613 struct PendingMessage *root = pm->frag_parent;
10614
10615 while (NULL != root->frag_parent)
10616 root = root->frag_parent;
10618 "Next attempt for root message <%" PRIu64 "> set to %s\n",
10619 root->logging_uuid,
10621 root->next_attempt = next_attempt;
10623 }
10624 else
10625 {
10626 struct PendingMessage *root = pm->frag_parent;
10627
10628 while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
10629 root = root->frag_parent;
10630
10632 "frag_count next attempt %u\n",
10633 root->frag_count);
10634
10635 if (GNUNET_NO == root->frags_in_flight)
10636 {
10637 root->next_attempt = next_attempt;
10639 root->frags_in_flight_round++;
10641 "Next attempt for fragmented message <%" PRIu64 "> (<%" PRIu64
10642 ">)set to %" PRIu64 "\n",
10643 pm->logging_uuid,
10644 root->logging_uuid,
10646 }
10647
10648 pm->next_attempt = root->next_attempt;
10649 pm->frags_in_flight_round = root->frags_in_flight_round;
10651
10652 if (root->bytes_msg == root->frag_off)
10653 root->frags_in_flight = check_next_attempt_tree (root, root);
10654 else
10656
10657 if (GNUNET_NO == root->frags_in_flight)
10658 {
10660 "We have no fragments in flight for message %" PRIu64
10661 ", reorder root! Next attempt is %" PRIu64 "\n",
10662 root->logging_uuid,
10664 if (PMT_DV_BOX == root->pmt)
10665 root = root->frag_parent;
10666 reorder_root_pm (root, root->next_attempt);
10667 // root->next_attempt = GNUNET_TIME_UNIT_ZERO_ABS;
10668 }
10669 else
10670 {
10671 double factor = ((double) root->frag_count - 1)
10672 / (double) root->frag_count;
10673 struct GNUNET_TIME_Relative s1;
10674 struct GNUNET_TIME_Relative s2;
10675 struct GNUNET_TIME_Relative plus_mean =
10678 next_attempt);
10679
10681 "frag_count %u after factor\n",
10682 root->frag_count);
10684 factor);
10685 s2 = GNUNET_TIME_relative_divide (plus,
10686 root->frag_count);
10687 plus_mean = GNUNET_TIME_relative_add (s1, s2);
10690 "We have fragments in flight for message %" PRIu64
10691 ", do not reorder root! Actual next attempt %" PRIu64 "\n",
10692 root->logging_uuid,
10694 }
10695 }
10696}
static void reorder_root_pm(struct PendingMessage *pm, struct GNUNET_TIME_Absolute next_attempt)
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply_double(struct GNUNET_TIME_Relative rel, double factor)
Multiply relative time by a given factor.
Definition: time.c:506

References GNUNET_TIME_Absolute::abs_value_us, PendingMessage::bytes_msg, check_next_attempt_tree(), PendingMessage::frag_count, PendingMessage::frag_off, PendingMessage::frag_parent, PendingMessage::frags_in_flight, PendingMessage::frags_in_flight_round, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_multiply_double(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, harmonize_flight_round(), PendingMessage::logging_uuid, PendingMessage::next_attempt, pm, PendingMessage::pmt, PMT_DV_BOX, PMT_RELIABILITY_BOX, and reorder_root_pm().

Referenced by transmit_on_queue().

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

◆ select_best_pending_from_link()

static void select_best_pending_from_link ( struct PendingMessageScoreContext sc,
struct Queue queue,
struct VirtualLink vl,
struct DistanceVectorHop dvh,
size_t  overhead 
)
static

Select the best pending message from vl for transmission via queue.

Parameters
[in,out]scbest message so far (NULL for none), plus scoring data
queuethe queue that will be used for transmission
vlthe virtual link providing the messages
dvhpath we are currently considering, or NULL for none
overheadnumber of bytes of overhead to be expected from DV encapsulation (0 for without DV)

Definition at line 10763 of file gnunet-service-transport.c.

10768{
10769 struct GNUNET_TIME_Absolute now;
10770
10771 now = GNUNET_TIME_absolute_get ();
10772 sc->to_early = GNUNET_NO;
10773 sc->frags_in_flight = GNUNET_NO;
10774 for (struct PendingMessage *pos = vl->pending_msg_head; NULL != pos;
10775 pos = pos->next_vl)
10776 {
10777 size_t real_overhead = overhead;
10778 int frag;
10779 int relb;
10780
10781 if ((NULL != dvh) && (PMT_DV_BOX == pos->pmt))
10782 {
10784 "DV messages must not be DV-routed to next hop!\n");
10785 continue; /* DV messages must not be DV-routed to next hop! */
10786 }
10787 if (pos->next_attempt.abs_value_us > now.abs_value_us)
10788 {
10789 if (GNUNET_YES == pos->frags_in_flight)
10790 {
10791 sc->frags_in_flight = GNUNET_YES;
10793 "Fragments in flight for message %" PRIu64 "\n",
10794 pos->logging_uuid);
10795 }
10796 else
10797 {
10799 "Maybe too early, because message are sorted by next_attempt, if there are no fragments in flight.Checked message %"
10800 PRIu64 "\n",
10801 pos->logging_uuid);
10802 sc->to_early = GNUNET_YES;
10803 sc->to_early_retry_delay = GNUNET_TIME_absolute_get_remaining (
10804 pos->next_attempt);
10805 continue;
10806 }
10807 // break; /* too early for all messages, they are sorted by next_attempt */
10808 }
10809 if (NULL != pos->qe)
10810 {
10812 "not eligible\n");
10813 continue; /* not eligible */
10814 }
10815 sc->consideration_counter++;
10816 /* determine if we have to fragment, if so add fragmentation
10817 overhead! */
10819 "check %" PRIu64 " for sc->best\n",
10820 pos->logging_uuid);
10821 frag = GNUNET_NO;
10822 if (((0 != queue->mtu) &&
10823 (pos->bytes_msg + real_overhead > queue->mtu)) ||
10824 (pos->bytes_msg > UINT16_MAX - sizeof(struct
10826 ||
10827 (NULL != pos->head_frag /* fragments already exist, should
10828 respect that even if MTU is UINT16_MAX for
10829 this queue */))
10830 {
10832 "fragment msg with size %u, realoverhead is %lu\n",
10833 pos->bytes_msg,
10834 real_overhead);
10835 frag = GNUNET_YES;
10836 if (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc)
10837 {
10838 /* FIXME-FRAG-REL-UUID: we could use an optimized, shorter fragmentation
10839 header without the ACK UUID when using a *reliable* channel! */
10840 }
10841 real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
10842 }
10843 /* determine if we have to reliability-box, if so add reliability box
10844 overhead */
10845 relb = GNUNET_NO;
10846 if ((GNUNET_NO == frag) &&
10847 (0 == (pos->prefs & GNUNET_MQ_PREF_UNRELIABLE)) &&
10848 (GNUNET_TRANSPORT_CC_RELIABLE != queue->tc->details.communicator.cc))
10849 {
10850 real_overhead += sizeof(struct TransportReliabilityBoxMessage);
10851
10852 if ((0 != queue->mtu) && (pos->bytes_msg + real_overhead > queue->mtu))
10853 {
10854 frag = GNUNET_YES;
10855 real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
10856 }
10857 else
10858 {
10859 relb = GNUNET_YES;
10860 }
10862 "Create reliability box of msg with size %u, realoverhead is %lu %u %u %u\n",
10863 pos->bytes_msg,
10864 real_overhead,
10865 queue->mtu,
10866 frag,
10867 relb);
10868 }
10869
10870 /* Finally, compare to existing 'best' in sc to see if this 'pos' pending
10871 message would beat it! */
10872 if (GNUNET_NO == sc->frags_in_flight && NULL != sc->best)
10873 {
10874 /* CHECK if pos fits queue BETTER (=smaller) than pm, if not: continue;
10875 OPTIMIZE-ME: This is a heuristic, which so far has NOT been
10876 experimentally validated. There may be some huge potential for
10877 improvement here. Also, we right now only compare how well the
10878 given message fits _this_ queue, and do not consider how well other
10879 queues might suit the message. Taking other queues into consideration
10880 may further improve the result, but could also be expensive
10881 in terms of CPU time. */
10882 long long sc_score = sc->frag * 40 + sc->relb * 20 + sc->real_overhead;
10883 long long pm_score = frag * 40 + relb * 20 + real_overhead;
10884 long long time_delta =
10885 (sc->best->next_attempt.abs_value_us - pos->next_attempt.abs_value_us)
10886 / 1000LL;
10887
10888 /* "time_delta" considers which message has been 'ready' for transmission
10889 for longer, if a message has a preference for low latency, increase
10890 the weight of the time_delta by 10x if it is favorable for that message */
10891 if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
10892 (0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)))
10893 time_delta *= 10; /* increase weight (always, both are low latency) */
10894 else if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
10895 (time_delta > 0))
10896 time_delta *= 10; /* increase weight, favors 'pos', which is low latency */
10897 else if ((0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
10898 (time_delta < 0))
10899 time_delta *= 10; /* increase weight, favors 'sc->best', which is low latency */
10900 if (0 != queue->mtu)
10901 {
10902 /* Grant bonus if we are below MTU, larger bonus the closer we will
10903 be to the MTU */
10904 if (queue->mtu > sc->real_overhead + sc->best->bytes_msg)
10905 sc_score -= queue->mtu - (sc->real_overhead + sc->best->bytes_msg);
10906 if (queue->mtu > real_overhead + pos->bytes_msg)
10907 pm_score -= queue->mtu - (real_overhead + pos->bytes_msg);
10908 }
10909 if (sc_score + time_delta > pm_score)
10910 {
10912 "sc_score of %" PRIu64 " larger, keep sc->best %" PRIu64
10913 "\n",
10914 pos->logging_uuid,
10915 sc->best->logging_uuid);
10916 continue; /* sc_score larger, keep sc->best */
10917 }
10918 }
10919 sc->best = pos;
10920 sc->dvh = dvh;
10921 sc->frag = frag;
10922 sc->relb = relb;
10923 sc->real_overhead = real_overhead;
10924 }
10925}
@ GNUNET_MQ_PREF_UNRELIABLE
Flag to indicate that unreliable delivery is acceptable.
@ GNUNET_MQ_PREF_LOW_LATENCY
Flag to indicate that low latency is important.
struct PendingMessage * next_vl
Kept in a MDLL of messages for this vl.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_PREF_LOW_LATENCY, GNUNET_MQ_PREF_UNRELIABLE, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_YES, PendingMessage::next_vl, VirtualLink::pending_msg_head, PMT_DV_BOX, queue(), and sc.

Referenced by transmit_on_queue().

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

◆ extract_box_cb()

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

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

Parameters
clsa struct PendingMessageScoreContext
next_hopnext hop of the DV path
hdrencapsulated message, technically a struct TransportDVBoxMessage
optionsoptions of the original message

Definition at line 10939 of file gnunet-service-transport.c.

10943{
10944 struct PendingMessageScoreContext *sc = cls;
10945 struct PendingMessage *pm = sc->best;
10946 struct PendingMessage *bpm;
10947 uint16_t bsize = ntohs (hdr->size);
10948
10949 GNUNET_assert (NULL == pm->bpm);
10950 bpm = GNUNET_malloc (sizeof(struct PendingMessage) + bsize);
10952 "5 created pm %p storing vl %p from pm %p\n",
10953 bpm,
10954 pm->vl,
10955 pm);
10957 bpm->pmt = PMT_DV_BOX;
10958 bpm->vl = pm->vl;
10959 bpm->timeout = pm->timeout;
10960 bpm->bytes_msg = bsize;
10961 bpm->frag_parent = pm;
10964 "Creating DV Box %" PRIu64 " for original message %" PRIu64
10965 " (next hop is %s)\n",
10967 pm->logging_uuid,
10968 GNUNET_i2s (&next_hop->pid));
10969 memcpy (&bpm[1], hdr, bsize);
10970 pm->bpm = bpm;
10971}

References PendingMessage::bpm, bsize, PendingMessage::bytes_msg, PendingMessage::frag_parent, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, PendingMessage::logging_uuid, logging_uuid_gen, Neighbour::pid, pm, PendingMessage::pmt, PMT_DV_BOX, sc, set_pending_message_uuid(), GNUNET_MessageHeader::size, PendingMessage::timeout, and PendingMessage::vl.

Referenced by transmit_on_queue().

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

◆ handle_del_queue_message()

static void handle_del_queue_message ( void *  cls,
const struct GNUNET_TRANSPORT_DelQueueMessage dqm 
)
static

Queue to a peer went down.

Process the request.

Parameters
clsthe client
dqmthe send message that was sent

Definition at line 11246 of file gnunet-service-transport.c.

11248{
11249 struct TransportClient *tc = cls;
11250
11251 if (CT_COMMUNICATOR != tc->type)
11252 {
11253 GNUNET_break (0);
11255 return;
11256 }
11257 for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
11258 queue = queue->next_client)
11259 {
11260 struct Neighbour *neighbour = queue->neighbour;
11261
11262 if ((ntohl (dqm->qid) != queue->qid) ||
11263 (0 != GNUNET_memcmp (&dqm->receiver, &neighbour->pid)))
11264 continue;
11266 "Dropped queue %s to peer %s\n",
11267 queue->address,
11268 GNUNET_i2s (&neighbour->pid));
11269 free_queue (queue);
11271 return;
11272 }
11273 GNUNET_break (0);
11275}
struct GNUNET_PeerIdentity receiver
Receiver that can be addressed via the queue.
Definition: transport.h:513
uint32_t qid
Address identifier.
Definition: transport.h:508

References CT_COMMUNICATOR, free_queue(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), Neighbour::pid, GNUNET_TRANSPORT_DelQueueMessage::qid, queue(), GNUNET_TRANSPORT_DelQueueMessage::receiver, and tc.

Here is the call graph for this function:

◆ handle_send_message_ack()

static void handle_send_message_ack ( void *  cls,
const struct GNUNET_TRANSPORT_SendMessageToAck sma 
)
static

Message was transmitted.

Process the request.

Parameters
clsthe client
smathe send message that was sent

Definition at line 11376 of file gnunet-service-transport.c.

11378{
11379 struct TransportClient *tc = cls;
11380 struct QueueEntry *qe;
11381
11382 if (CT_COMMUNICATOR != tc->type)
11383 {
11384 GNUNET_break (0);
11386 return;
11387 }
11388
11389 /* find our queue entry matching the ACK */
11390 qe = NULL;
11392 "Looking for queue for PID %s\n",
11393 GNUNET_i2s (&sma->receiver));
11394 for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
11395 queue = queue->next_client)
11396 {
11397 if (0 != GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver))
11398 continue;
11400 "Found PID %s\n",
11401 GNUNET_i2s (&queue->neighbour->pid));
11402
11403
11404 for (struct QueueEntry *qep = queue->queue_head; NULL != qep;
11405 qep = qep->next)
11406 {
11407 if (qep->mid != GNUNET_ntohll (sma->mid) || queue->qid != ntohl (
11408 sma->qid))
11409 continue;
11411 "QueueEntry MID: %" PRIu64 " on queue QID: %u, Ack MID: %"
11412 PRIu64 " Ack QID %u\n",
11413 qep->mid,
11414 queue->qid,
11415 GNUNET_ntohll (sma->mid),
11416 ntohl (sma->qid));
11417 qe = qep;
11418 if ((NULL != qe->pm) && (qe->pm->qe != qe))
11420 "For pending message %" PRIu64 " we had retransmissions.\n",
11421 qe->pm->logging_uuid);
11422 break;
11423 }
11424 }
11425 if (NULL == qe)
11426 {
11428 "No QueueEntry found for Ack MID %" PRIu64 " QID: %u\n",
11429 GNUNET_ntohll (sma->mid),
11430 ntohl (sma->qid));
11431 // TODO I guess this can happen, if the Ack from the peer comes before the Ack from the queue.
11432 // Update: Maybe QueueEntry was accidentally freed during freeing PendingMessage.
11433 /* this should never happen */
11434 // GNUNET_break (0);
11435 // GNUNET_SERVICE_client_drop (tc->client);
11437 return;
11438 }
11441}
uint64_t mid
Message ID of the original message.
Definition: transport.h:606
uint32_t qid
Queue ID for the queue which was used to send the message.
Definition: transport.h:611
struct GNUNET_PeerIdentity receiver
Receiver identifier.
Definition: transport.h:616

References CT_COMMUNICATOR, free_queue_entry(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TRANSPORT_SendMessageToAck::mid, qe, GNUNET_TRANSPORT_SendMessageToAck::qid, queue(), GNUNET_TRANSPORT_SendMessageToAck::receiver, and tc.

Here is the call graph for this function:

◆ handle_burst_finished()

static void handle_burst_finished ( )
static

The burst finished.

Parameters
clsthe client

Definition at line 11450 of file gnunet-service-transport.c.

11451{
11453}

References burst_running, and GNUNET_NO.

◆ notify_client_queues()

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

Iterator telling new MONITOR client about all existing queues 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 11466 of file gnunet-service-transport.c.

11469{
11470 struct TransportClient *tc = cls;
11471 struct Neighbour *neighbour = value;
11472
11473 GNUNET_assert (CT_MONITOR == tc->type);
11474 for (struct Queue *q = neighbour->queue_head; NULL != q;
11475 q = q->next_neighbour)
11476 {
11477 struct MonitorEvent me = { .rtt = q->pd.aged_rtt,
11478 .cs = q->cs,
11479 .num_msg_pending = q->num_msg_pending,
11480 .num_bytes_pending = q->num_bytes_pending };
11481
11482 notify_monitor (tc, pid, q->address, q->nt, &me);
11483 }
11484 return GNUNET_OK;
11485}

References CT_MONITOR, GNUNET_assert, GNUNET_OK, me, notify_monitor(), pid, q, Neighbour::queue_head, tc, and value.

Referenced by handle_monitor_start().

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

◆ handle_monitor_start()

static void handle_monitor_start ( void *  cls,
const struct GNUNET_TRANSPORT_MonitorStart start 
)
static

Initialize a monitor client.

Parameters
clsthe client
startthe start message that was sent

Definition at line 11495 of file gnunet-service-transport.c.

11497{
11498 struct TransportClient *tc = cls;
11499
11500 if (CT_NONE != tc->type)
11501 {
11502 GNUNET_break (0);
11504 return;
11505 }
11506 tc->type = CT_MONITOR;
11507 tc->details.monitor.peer = start->peer;
11508 tc->details.monitor.one_shot = ntohl (start->one_shot);
11512}
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.
void GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c)
Set the 'monitor' flag on this client.
Definition: service.c:2483

References CT_MONITOR, CT_NONE, GNUNET_break, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_mark_monitor(), neighbours, notify_client_queues(), start, and tc.

Here is the call graph for this function:

◆ lookup_communicator()

static struct TransportClient * lookup_communicator ( const char *  prefix)
static

Find transport client providing communication service for the protocol prefix.

Parameters
prefixcommunicator name
Returns
NULL if no such transport client is available

Definition at line 11523 of file gnunet-service-transport.c.

11524{
11525 for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
11526 {
11527 if (CT_COMMUNICATOR != tc->type)
11528 continue;
11529 if (0 == strcmp (prefix, tc->details.communicator.address_prefix))
11530 return tc;
11531 }
11532 GNUNET_log (
11534 "Someone suggested use of communicator for `%s', but we do not have such a communicator!\n",
11535 prefix);
11536 return NULL;
11537}

References clients_head, CT_COMMUNICATOR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, prefix, and tc.

Referenced by suggest_to_connect().

Here is the caller graph for this function:

◆ check_connection_quality()

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

Check whether any queue to the given neighbour is of a good "quality" and if so, increment the counter.

Also counts the total number of queues, and returns the k-th queue found.

Parameters
clsa struct QueueQualityContext * with counters
pidpeer this is about
valuea struct Neighbour
Returns
GNUNET_OK (continue to iterate)

Definition at line 11749 of file gnunet-service-transport.c.

11752{
11753 struct QueueQualityContext *ctx = cls;
11754 struct Neighbour *n = value;
11755 int do_inc;
11756
11757 (void) pid;
11758 do_inc = GNUNET_NO;
11759 for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
11760 {
11761 ctx->num_queues++;
11762 if (0 == ctx->k--)
11763 ctx->q = q;
11764 /* FIXME-CONQ-STATISTICS: in the future, add reliability / goodput
11765 statistics and consider those as well here? */
11766 if (q->pd.aged_rtt.rel_value_us < DV_QUALITY_RTT_THRESHOLD.rel_value_us)
11767 do_inc = GNUNET_YES;
11768 }
11769 if (GNUNET_YES == do_inc)
11770 ctx->quality_count++;
11771 return GNUNET_OK;
11772}
#define DV_QUALITY_RTT_THRESHOLD
We only consider queues as "quality" connections when suppressing the generation of DV initiation mes...
Closure for check_connection_quality.

References ctx, DV_QUALITY_RTT_THRESHOLD, GNUNET_NO, GNUNET_OK, GNUNET_YES, pid, q, Neighbour::queue_head, and value.

Referenced by start_dv_learn().

Here is the caller graph for this function:

◆ start_dv_learn()

static void start_dv_learn ( void *  cls)
static

Task run when we CONSIDER initiating a DV learn process.

We first check that sending out a message is even possible (queues exist), then that it is desirable (if not, reschedule the task for later), and finally we may then begin the job. If there are too many entries in the dvlearn_map, we purge the oldest entry using lle_tail.

Parameters
clsNULL

Definition at line 11787 of file gnunet-service-transport.c.

11788{
11789 struct LearnLaunchEntry *lle;
11790 struct QueueQualityContext qqc;
11791 struct TransportDVLearnMessage dvl;
11792
11793 (void) cls;
11794 dvlearn_task = NULL;
11796 return; /* lost all connectivity, cannot do learning */
11797 qqc.quality_count = 0;
11798 qqc.num_queues = 0;
11802 &qqc);
11803 if (qqc.quality_count > DV_LEARN_QUALITY_THRESHOLD)
11804 {
11805 struct GNUNET_TIME_Relative delay;
11806 unsigned int factor;
11807
11808 /* scale our retries by how far we are above the threshold */
11809 factor = qqc.quality_count / DV_LEARN_QUALITY_THRESHOLD;
11812 "At connection quality %u, will launch DV learn in %s\n",
11813 qqc.quality_count,
11816 return;
11817 }
11818 /* remove old entries in #dvlearn_map if it has grown too big */
11819 while (MAX_DV_LEARN_PENDING <=
11821 {
11822 lle = lle_tail;
11825 &lle->challenge.value,
11826 lle));
11828 GNUNET_free (lle);
11829 }
11830 /* setup data structure for learning */
11831 lle = GNUNET_new (struct LearnLaunchEntry);
11833 &lle->challenge,
11834 sizeof(lle->challenge));
11836 "Starting launch DV learn with challenge %s\n",
11837 GNUNET_sh2s (&lle->challenge.value));
11842 &lle->challenge.value,
11843 lle,
11845 dvl.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
11846 dvl.header.size = htons (sizeof(dvl));
11847 dvl.num_hops = htons (0);
11848 dvl.bidirectional = htons (0);
11849 dvl.non_network_delay = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO);
11850 dvl.monotonic_time =
11852 {
11853 struct DvInitPS dvip = {
11854 .purpose.purpose = htonl (
11856 .purpose.size = htonl (sizeof(dvip)),
11857 .monotonic_time = dvl.monotonic_time,
11858 .challenge = lle->challenge
11859 };
11860
11862 &dvip,
11863 &dvl.init_sig);
11864 }
11865 dvl.initiator = GST_my_identity;
11866 dvl.challenge = lle->challenge;
11867
11868 qqc.quality_count = 0;
11869 qqc.k = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, qqc.num_queues);
11870 qqc.num_queues = 0;
11871 qqc.q = NULL;
11874 &qqc);
11875 GNUNET_assert (NULL != qqc.q);
11876
11877 /* Do this as close to transmission time as possible! */
11879
11880 queue_send_msg (qqc.q, NULL, &dvl, sizeof(dvl));
11881 /* reschedule this job, randomizing the time it runs (but no
11882 actual backoff!) */
11886 NULL);
11887}
static void start_dv_learn(void *cls)
Task run when we CONSIDER initiating a DV learn process.
#define DV_LEARN_QUALITY_THRESHOLD
How many good connections (confirmed, bi-directional, not DV) do we need to have to suppress initiati...
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 counte...
#define DV_LEARN_BASE_FREQUENCY
What is the non-randomized base frequency at which we would initiate DV learn messages?
#define MAX_DV_LEARN_PENDING
Maximum number of DV learning activities we may have pending at the same time.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
unsigned int GNUNET_CONTAINER_multishortmap_size(const struct GNUNET_CONTAINER_MultiShortmap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multishortmap_remove(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_TIME_Relative GNUNET_TIME_randomize(struct GNUNET_TIME_Relative r)
Return a random time value between 0.5*r and 1.5*r.
Definition: time.c:855
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge that uniquely identifies this activity.
struct GNUNET_TIME_Absolute launch_time
When did we transmit the DV learn message (used to calculate RTT) and determine freshness of paths le...

References TransportDVLearnMessage::bidirectional, TransportDVLearnMessage::challenge, LearnLaunchEntry::challenge, check_connection_quality(), DV_LEARN_BASE_FREQUENCY, DV_LEARN_QUALITY_THRESHOLD, dvlearn_map, dvlearn_task, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_CRYPTO_eddsa_sign, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_block(), GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_randomize(), GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GST_cfg, GST_my_identity, GST_my_private_key, TransportDVLearnMessage::header, TransportDVLearnMessage::init_sig, TransportDVLearnMessage::initiator, QueueQualityContext::k, LearnLaunchEntry::launch_time, lle_head, lle_tail, MAX_DV_LEARN_PENDING, TransportDVLearnMessage::monotonic_time, neighbours, TransportDVLearnMessage::non_network_delay, TransportDVLearnMessage::num_hops, QueueQualityContext::num_queues, GNUNET_CRYPTO_EccSignaturePurpose::purpose, DvInitPS::purpose, QueueQualityContext::q, QueueQualityContext::quality_count, queue_send_msg(), GNUNET_MessageHeader::size, start_dv_learn(), GNUNET_MessageHeader::type, and GNUNET_CRYPTO_ChallengeNonceP::value.

Referenced by handle_add_queue_message(), and start_dv_learn().

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

◆ check_validation_request_pending()

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

A new queue has been created, check if any address validation requests have been waiting for it.

Parameters
clsa struct Queue
pidpeer concerned (unused)
valuea struct ValidationState
Returns
GNUNET_NO if a match was found and we can stop looking

Definition at line 11925 of file gnunet-service-transport.c.

11928{
11929 struct Queue *q = cls;
11930 struct ValidationState *vs = value;
11931 char *address_without_port_vs;
11932 char *address_without_port_q;
11933 int success = GNUNET_YES;
11934
11935 // TODO Check if this is really necessary.
11936 address_without_port_vs = get_address_without_port (vs->address);
11937 address_without_port_q = get_address_without_port (q->address);
11938
11940 "Check validation request pending for `%s' at `%s'/`%s' (vs)/(q)\n",
11941 GNUNET_i2s (pid),
11942 address_without_port_vs,
11943 address_without_port_q);
11944 (void) pid;
11945 if ((GNUNET_YES == vs->awaiting_queue) &&
11946 (0 == strcmp (address_without_port_vs, address_without_port_q)))
11947 {
11948
11949 vs->awaiting_queue = GNUNET_NO;
11951 success = GNUNET_NO;
11952 }
11953
11954 GNUNET_free (address_without_port_vs);
11955 GNUNET_free (address_without_port_q);
11956 return success;
11957}

References get_address_without_port(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, pid, q, validation_transmit_on_queue(), and value.

Referenced by handle_add_queue_message().

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

◆ neighbour_dv_monotime_cb()

static void neighbour_dv_monotime_cb ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Function called with the monotonic time of a DV initiator by PEERSTORE.

Updates the time.

Parameters
clsa struct Neighbour
recordthe information found, NULL for the last call
emsgerror message

Definition at line 11969 of file gnunet-service-transport.c.

11972{
11973 struct Neighbour *n = cls;
11974 struct GNUNET_TIME_AbsoluteNBO *mtbe;
11975
11976 (void) emsg;
11977 if (NULL == record)
11978 {
11979 /* we're done with #neighbour_dv_monotime_cb() invocations,
11980 continue normal processing */
11981 n->get = NULL;
11983 return;
11984 }
11985 if (0 == record->value_size)
11986 {
11988 GNUNET_break (0);
11989 return;
11990 }
11991 mtbe = record->value;
11996}

References Neighbour::dv_monotime_available, Neighbour::get, GNUNET_break, GNUNET_PEERSTORE_iteration_next(), GNUNET_TIME_absolute_max(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, Neighbour::last_dv_learn_monotime, and record().

Referenced by handle_add_queue_message().

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

◆ iterate_address_and_compare_cb()

static void iterate_address_and_compare_cb ( void *  cls,
const struct GNUNET_PeerIdentity pid,
const char *  uri 
)
static

Definition at line 12000 of file gnunet-service-transport.c.

12003{
12004 struct Queue *queue = cls;
12005 struct sockaddr_in v4;
12006 const char *slash;
12007 char *address_uri;
12008 char *prefix;
12009 char *uri_without_port;
12010 char *address_uri_without_port;
12011
12012 slash = strrchr (uri, '/');
12013 prefix = GNUNET_strndup (uri, (slash - uri) - 2);
12014 GNUNET_assert (NULL != slash);
12015 slash++;
12016 GNUNET_asprintf (&address_uri,
12017 "%s-%s",
12018 prefix,
12019 slash);
12020
12022 "1 not global natted_address %u %s %s %s\n",
12023 queue->is_global_natted,
12024 uri,
12025 queue->address,
12026 slash);
12027
12028 uri_without_port = get_address_without_port (address_uri);
12029 if (1 != inet_pton (AF_INET, uri_without_port, &v4.sin_addr))
12030 {
12032 GNUNET_free (address_uri);
12033 GNUNET_free (uri_without_port);
12034 return;
12035 }
12036
12038 "2 not global natted_address %u %s %s\n",
12039 queue->is_global_natted,
12040 uri,
12041 queue->address);
12042
12043 if (GNUNET_NO == queue->is_global_natted)
12044 {
12046 GNUNET_free (address_uri);
12047 GNUNET_free (uri_without_port);
12048 return;
12049 }
12050
12052 "3 not global natted_address %u %s %s\n",
12053 queue->is_global_natted,
12054 uri,
12055 queue->address);
12056
12057 if (0 == strcmp (uri_without_port, address_uri))
12058 {
12060 GNUNET_free (address_uri);
12061 GNUNET_free (uri_without_port);
12062 return;
12063 }
12064
12066 "4 not global natted_address %u %s %s\n",
12067 queue->is_global_natted,
12068 uri,
12069 queue->address);
12070
12071 address_uri_without_port = get_address_without_port (queue->address);
12072 if (0 == strcmp (uri_without_port, address_uri_without_port))
12073 {
12074 queue->is_global_natted = GNUNET_NO;
12075 }
12076
12078 "not global natted_address %u %s %s %s %s %s %u\n",
12079 queue->is_global_natted,
12080 uri,
12081 queue->address,
12082 uri_without_port,
12083 address_uri_without_port,
12084 prefix,
12085 GNUNET_NO);
12087 GNUNET_free (address_uri);
12088 GNUNET_free (address_uri_without_port);
12089 GNUNET_free (uri_without_port);
12090}

References get_address_without_port(), GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_strndup, prefix, queue(), and uri.

Referenced by check_for_global_natted().

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

◆ contains_address()

static enum GNUNET_GenericReturnValue contains_address ( void *  cls,
const struct GNUNET_PeerIdentity pid,
void *  value 
)
static

Definition at line 12108 of file gnunet-service-transport.c.

12111{
12112 struct TransportGlobalNattedAddressClosure *tgna_cls = cls;
12113 struct TransportGlobalNattedAddress *tgna = value;
12114 char *addr = (char *) &tgna[1];
12115
12117 "Checking tgna %p with addr %s and length %u compare length %lu\n",
12118 tgna,
12119 addr,
12120 ntohl (tgna->address_length),
12121 strlen (tgna_cls->addr));
12122 if (strlen (tgna_cls->addr) == ntohl (tgna->address_length)
12123 && 0 == strncmp (addr, tgna_cls->addr, ntohl (tgna->address_length)))
12124 {
12125 tgna_cls->tgna = tgna;
12126 return GNUNET_NO;
12127 }
12128 return GNUNET_YES;
12129}
char * addr
The address to search for.
struct TransportGlobalNattedAddress * tgna
The struct TransportGlobalNattedAddress to set.

References TransportGlobalNattedAddressClosure::addr, TransportGlobalNattedAddress::address_length, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, TransportGlobalNattedAddressClosure::tgna, and value.

Referenced by check_for_global_natted().

Here is the caller graph for this function:

◆ check_for_global_natted_error_cb()

static void check_for_global_natted_error_cb ( void *  cls)
static

Definition at line 12133 of file gnunet-service-transport.c.

12134{
12136 "Error in PEERSTORE monitoring for checking global natted\n");
12137}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by handle_add_queue_message().

Here is the caller graph for this function:

◆ check_for_global_natted_sync_cb()

static void check_for_global_natted_sync_cb ( void *  cls)
static

Definition at line 12141 of file gnunet-service-transport.c.

12142{
12144 "Done with initial PEERSTORE iteration during monitoring for checking global natted\n");
12145}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by handle_add_queue_message().

Here is the caller graph for this function:

◆ check_for_global_natted()

static void check_for_global_natted ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Definition at line 12149 of file gnunet-service-transport.c.

12152{
12153 struct Queue *queue = cls;
12154 struct Neighbour *neighbour = queue->neighbour;
12156 struct GNUNET_MessageHeader *hello;
12158 size_t address_len_without_port;
12159
12160 if (NULL != emsg)
12161 {
12163 "Got failure from PEERSTORE: %s\n",
12164 emsg);
12165 return;
12166 }
12167 if (0 == record->value_size)
12168 {
12170 GNUNET_break (0);
12171 return;
12172 }
12173 queue->is_global_natted = GNUNET_YES;
12174 hello = record->value;
12177 "before not global natted %u\n",
12178 queue->is_global_natted);
12181 queue);
12183 "after not global natted %u\n",
12184 queue->is_global_natted);
12186
12187 tgna_cls.addr = get_address_without_port (queue->address);
12188 address_len_without_port = strlen (tgna_cls.addr);
12189 /*{
12190 char buf[address_len_without_port + 1];
12191
12192 GNUNET_memcpy (&buf, addr, address_len_without_port);
12193 buf[address_len_without_port] = '\0';
12194 GNUNET_free (addr);
12195 GNUNET_memcpy (tgna_cls.addr, buf, address_len_without_port + 1);
12196 }*/
12197 tgna_cls.tgna = NULL;
12199 &neighbour->pid,
12201 &tgna_cls);
12202 if (NULL != tgna_cls.tgna)
12204 " tgna_cls.tgna tgna %p %lu %u %u\n",
12205 tgna_cls.tgna,
12206 neighbour->size_of_global_addresses,
12207 ntohl (tgna_cls.tgna->address_length),
12208 neighbour->number_of_addresses);
12209 if (NULL == tgna_cls.tgna && GNUNET_YES == queue->is_global_natted)
12210 {
12211 struct TransportGlobalNattedAddress *tgna;
12212
12213 tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress)
12214 + address_len_without_port);
12215 tgna->address_length = htonl (address_len_without_port);
12216 GNUNET_memcpy (&tgna[1], tgna_cls.addr, address_len_without_port);
12218 &neighbour->pid,
12219 tgna,
12221 neighbour->number_of_addresses++;
12222 neighbour->size_of_global_addresses += address_len_without_port + 1;
12224 "Created tgna %p with address %s and length %lu\n",
12225 tgna,
12226 tgna_cls.addr,
12227 address_len_without_port + 1);
12228 }
12229 else if (NULL != tgna_cls.tgna && GNUNET_NO == queue->is_global_natted)
12230 {
12232 &neighbour->pid,
12233 tgna_cls.tgna);
12234 GNUNET_assert (neighbour->size_of_global_addresses >= ntohl (tgna_cls.tgna->
12236 );
12237 neighbour->size_of_global_addresses -= ntohl (tgna_cls.tgna->address_length)
12238 ;
12239 GNUNET_assert (0 < neighbour->number_of_addresses);
12240 neighbour->number_of_addresses--;
12242 "removed tgna %p\n",
12243 tgna_cls.tgna);
12244 GNUNET_free (tgna_cls.tgna);
12245 }
12247 GNUNET_free (tgna_cls.addr);
12248}
static enum GNUNET_GenericReturnValue contains_address(void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
static void iterate_address_and_compare_cb(void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)

References TransportGlobalNattedAddressClosure::addr, TransportGlobalNattedAddress::address_length, contains_address(), get_address_without_port(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_iterate(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_PEERSTORE_monitor_next(), GNUNET_YES, iterate_address_and_compare_cb(), Neighbour::natted_addresses, Neighbour::number_of_addresses, consensus-simulation::parser, Neighbour::pid, queue(), record(), Neighbour::size_of_global_addresses, and TransportGlobalNattedAddressClosure::tgna.

Referenced by handle_add_queue_message().

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

◆ handle_add_queue_message()

static void handle_add_queue_message ( void *  cls,
const struct GNUNET_TRANSPORT_AddQueueMessage aqm 
)
static

New queue became available.

Process the request.

Parameters
clsthe client
aqmthe send message that was sent

Definition at line 12258 of file gnunet-service-transport.c.

12260{
12261 struct TransportClient *tc = cls;
12262 struct Queue *queue;
12263 struct Neighbour *neighbour;
12264 const char *addr;
12265 uint16_t addr_len;
12266
12267 if (ntohl (aqm->mtu) <= sizeof(struct TransportFragmentBoxMessage))
12268 {
12269 /* MTU so small as to be useless for transmissions,
12270 required for #fragment_message()! */
12271 GNUNET_break_op (0);
12273 return;
12274 }
12275 /* This may simply be a queue update */
12276 for (queue = tc->details.communicator.queue_head;
12277 NULL != queue;
12278 queue = queue->next_client)
12279 {
12280 if (queue->qid != ntohl (aqm->qid))
12281 continue;
12282 break;
12283 }
12284
12285 if (NULL != queue)
12286 {
12287 neighbour = queue->neighbour;
12288 }
12289 else
12290 {
12291 struct GNUNET_TIME_Absolute validated_until = GNUNET_TIME_UNIT_ZERO_ABS;
12292
12293 neighbour = lookup_neighbour (&aqm->receiver);
12294 if (NULL == neighbour)
12295 {
12296 neighbour = GNUNET_new (struct Neighbour);
12298 GNUNET_YES);
12299 neighbour->pid = aqm->receiver;
12302 neighbours,
12303 &neighbour->pid,
12304 neighbour,
12306 neighbour->get =
12308 "transport",
12309 &neighbour->pid,
12312 neighbour);
12313 }
12314 addr_len = ntohs (aqm->header.size) - sizeof(*aqm);
12315 addr = (const char *) &aqm[1];
12317 "New queue %s to %s available with QID %u and q_len %" PRIu64
12318 " and mtu %u\n",
12319 addr,
12320 GNUNET_i2s (&aqm->receiver),
12321 ntohl (aqm->qid),
12322 GNUNET_ntohll (aqm->q_len),
12323 ntohl (aqm->mtu));
12324 queue = GNUNET_malloc (sizeof(struct Queue) + addr_len);
12325 queue->tc = tc;
12326 for (struct Queue *q = neighbour->queue_head; NULL != q; q = q->
12327 next_neighbour)
12328 validated_until = GNUNET_TIME_absolute_max (validated_until, q->
12329 validated_until);
12330 if (0 == GNUNET_TIME_absolute_get_remaining (validated_until).rel_value_us)
12331 {
12333 "New queue with QID %u inherit validated until\n",
12334 ntohl (aqm->qid));
12335 queue->validated_until = validated_until;
12336 }
12337 queue->address = (const char *) &queue[1];
12338 queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
12339 queue->qid = ntohl (aqm->qid);
12340 queue->neighbour = neighbour;
12342 queue->unlimited_length = GNUNET_YES;
12343 queue->q_capacity = GNUNET_ntohll (aqm->q_len);
12344 memcpy (&queue[1], addr, addr_len);
12345 /* notify monitors about new queue */
12346 {
12347 struct MonitorEvent me = { .rtt = queue->pd.aged_rtt, .cs = queue->cs };
12348
12349 notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
12350 }
12352 neighbour->queue_head,
12353 neighbour->queue_tail,
12354 queue);
12356 tc->details.communicator.queue_head,
12357 tc->details.communicator.queue_tail,
12358 queue);
12359
12360 }
12361 queue->mtu = ntohl (aqm->mtu);
12362 queue->nt = ntohl (aqm->nt);
12363 queue->cs = ntohl (aqm->cs);
12364 queue->idle = GNUNET_YES;
12365
12366 {
12367 struct sockaddr_in v4;
12368 char *addr_without = get_address_without_port (queue->address);
12369 if (1 == inet_pton (AF_INET, addr_without, &v4.sin_addr))
12370 {
12372 "start not global natted\n");
12374 GNUNET_YES,
12375 "peerstore",
12376 &neighbour->pid,
12378 &
12380 NULL,
12381 &
12383 NULL,
12385 queue);
12386 }
12387 GNUNET_free (addr_without);
12388 }
12389 /* check if valdiations are waiting for the queue */
12391 &aqm->receiver))
12392 {
12395 &aqm->
12396 receiver,
12397 &
12399 queue))
12400 start_address_validation (&aqm->receiver, queue->address);
12401 }
12402 else
12403 start_address_validation (&aqm->receiver, queue->address);
12404 /* look for traffic for this queue */
12405 // TODO Check whether this makes any sense at all.
12406 /*schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
12407 queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT);*/
12408 /* might be our first queue, try launching DV learning */
12409 if (NULL == dvlearn_task)
12412}
static void check_for_global_natted(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
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.
static void check_for_global_natted_sync_cb(void *cls)
static void check_for_global_natted_error_cb(void *cls)
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.
#define GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED
Queue length.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:330
uint32_t nt
An enum GNUNET_NetworkType in NBO.
Definition: transport.h:420
uint32_t mtu
Maximum transmission unit, in NBO.
Definition: transport.h:425
uint64_t q_len
Queue length, in NBO.
Definition: transport.h:431
uint32_t qid
Queue identifier (used to identify the queue).
Definition: transport.h:410
struct GNUNET_PeerIdentity receiver
Receiver that can be addressed via the queue.
Definition: transport.h:415
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP.
Definition: transport.h:405
uint32_t cs
An enum GNUNET_TRANSPORT_ConnectionStatus in NBO.
Definition: transport.h:441

References check_for_global_natted(), check_for_global_natted_error_cb(), check_for_global_natted_sync_cb(), check_validation_request_pending(), GNUNET_TRANSPORT_AddQueueMessage::cs, dvlearn_task, Neighbour::get, get_address_without_port(), GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_MDLL_insert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_new, GNUNET_ntohll(), GNUNET_OK, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_iteration_start(), GNUNET_PEERSTORE_monitor_start(), GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME, GNUNET_SCHEDULER_add_now(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_max(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, GNUNET_YES, GST_cfg, GNUNET_TRANSPORT_AddQueueMessage::header, lookup_neighbour(), me, GNUNET_TRANSPORT_AddQueueMessage::mtu, Neighbour::natted_addresses, neighbour_dv_monotime_cb(), neighbours, notify_monitors(), GNUNET_TRANSPORT_AddQueueMessage::nt, peerstore, Neighbour::pid, q, GNUNET_TRANSPORT_AddQueueMessage::q_len, GNUNET_TRANSPORT_AddQueueMessage::qid, queue(), Neighbour::queue_head, Neighbour::queue_tail, receiver(), GNUNET_TRANSPORT_AddQueueMessage::receiver, GNUNET_MessageHeader::size, start_address_validation(), start_dv_learn(), tc, and validation_map.

Here is the call graph for this function:

◆ handle_update_queue_message()

static void handle_update_queue_message ( void *  cls,
const struct GNUNET_TRANSPORT_UpdateQueueMessage msg 
)
static

Handle updates to queues.

Parameters
clsthe transport client.
msgMessage struct.

Definition at line 12422 of file gnunet-service-transport.c.

12425{
12426 struct TransportClient *tc = cls;
12427 struct Queue *target_queue = NULL;
12428
12430 "Received queue update message for %u with q_len %llu and mtu %u\n",
12431 ntohl (msg->qid),
12432 (unsigned long long) GNUNET_ntohll (msg->q_len),
12433 ntohl (msg->mtu));
12434 for (target_queue = tc->details.communicator.queue_head;
12435 NULL != target_queue;
12436 target_queue = target_queue->next_client)
12437 {
12438 if (ntohl (msg->qid) == target_queue->qid)
12439 break;
12440 }
12441 if (NULL == target_queue)
12442 {
12444 "Queue to update no longer exists! Discarding update.\n");
12445 return;
12446 }
12447
12448 target_queue->nt = msg->nt;
12449 target_queue->mtu = ntohl (msg->mtu);
12450 target_queue->cs = msg->cs;
12451 target_queue->priority = ntohl (msg->priority);
12452 /* The update message indicates how many messages
12453 * the queue should be able to handle.
12454 */
12456 target_queue->unlimited_length = GNUNET_YES;
12457 else
12458 target_queue->unlimited_length = GNUNET_NO;
12459 target_queue->q_capacity += GNUNET_ntohll (msg->q_len);
12460 if (0 < target_queue->q_capacity)
12462 target_queue,
12465}
uint32_t qid
Unique identifier of this queue with the communicator.
uint64_t q_capacity
Capacity of the queue.
uint32_t priority
Queue priority.
enum GNUNET_NetworkType nt
Which network type does this queue use?
uint32_t mtu
Maximum transmission unit supported by this queue.
unsigned int unlimited_length
Is this queue of unlimited length.
enum GNUNET_TRANSPORT_ConnectionStatus cs
The connection status of this queue.

References Queue::cs, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SERVICE_client_continue(), GNUNET_TIME_UNIT_ZERO, GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, GNUNET_YES, msg, Queue::mtu, Queue::next_client, Queue::nt, Queue::priority, Queue::q_capacity, Queue::qid, schedule_transmit_on_queue(), tc, and Queue::unlimited_length.

Here is the call graph for this function:

◆ handle_queue_create_ok()

static void handle_queue_create_ok ( void *  cls,
const struct GNUNET_TRANSPORT_CreateQueueResponse cqr 
)
static

Communicator tells us that our request to create a queue "worked", that is setting up the queue is now in process.

Parameters
clsthe struct TransportClient
cqrconfirmation message

Definition at line 12476 of file gnunet-service-transport.c.

12478{
12479 struct TransportClient *tc = cls;
12480
12481 if (CT_COMMUNICATOR != tc->type)
12482 {
12483 GNUNET_break (0);
12485 return;
12486 }
12488 "# Suggestions succeeded at communicator",
12489 1,
12490 GNUNET_NO);
12492 "Request #%u for communicator to create queue succeeded\n",
12493 (unsigned int) ntohs (cqr->request_id));
12495}
uint32_t request_id
Unique ID for the request.
Definition: transport.h:555

References CT_COMMUNICATOR, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GST_stats, GNUNET_TRANSPORT_CreateQueueResponse::request_id, and tc.

Here is the call graph for this function:

◆ handle_queue_create_fail()

static void handle_queue_create_fail ( void *  cls,
const struct GNUNET_TRANSPORT_CreateQueueResponse cqr 
)
static

Communicator tells us that our request to create a queue failed.

This usually indicates that the provided address is simply invalid or that the communicator's resources are exhausted.

Parameters
clsthe struct TransportClient
cqrfailure message

Definition at line 12507 of file gnunet-service-transport.c.

12510{
12511 struct TransportClient *tc = cls;
12512
12513 if (CT_COMMUNICATOR != tc->type)
12514 {
12515 GNUNET_break (0);
12517 return;
12518 }
12520 "Request #%u for communicator to create queue failed\n",
12521 (unsigned int) ntohs (cqr->request_id));
12523 "# Suggestions failed in queue creation at communicator",
12524 1,
12525 GNUNET_NO);
12527}

References CT_COMMUNICATOR, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GST_stats, GNUNET_TRANSPORT_CreateQueueResponse::request_id, and tc.

Here is the call graph for this function:

◆ handle_suggest_cancel()

static void handle_suggest_cancel ( void *  cls,
const struct ExpressPreferenceMessage msg 
)
static

We have received a struct ExpressPreferenceMessage from an application client.

Parameters
clshandle to the client
msgthe start message

Definition at line 12538 of file gnunet-service-transport.c.

12539{
12540 struct TransportClient *tc = cls;
12541 struct PeerRequest *pr;
12542
12543 if (CT_APPLICATION != tc->type)
12544 {
12545 GNUNET_break (0);
12547 return;
12548 }
12549 pr = GNUNET_CONTAINER_multipeermap_get (tc->details.application.requests,
12550 &msg->peer);
12551 if (NULL == pr)
12552 {
12553 GNUNET_break (0);
12555 return;
12556 }
12557 (void) stop_peer_request (tc, &pr->pid, pr);
12559}

References CT_APPLICATION, GNUNET_break, GNUNET_CONTAINER_multipeermap_get(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), msg, PeerRequest::pr, stop_peer_request(), and tc.

Here is the call graph for this function:

◆ hello_for_client_cb()

static void hello_for_client_cb ( void *  cls,
const struct GNUNET_PeerIdentity pid,
const char *  uri 
)
static

Definition at line 12563 of file gnunet-service-transport.c.

12566{
12567 struct Queue *q;
12568 int pfx_len;
12569 const char *eou;
12570 char *address;
12571 (void) cls;
12572
12573 eou = strstr (uri,
12574 "://");
12575 pfx_len = eou - uri;
12576 eou += 3;
12578 "%.*s-%s",
12579 pfx_len,
12580 uri,
12581 eou);
12582
12584 "hello for client %s\n",
12585 address);
12586
12587 q = find_queue (pid, address);
12588 if (NULL == q)
12589 {
12591 }
12592 else
12595}

References address, find_queue(), GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, pid, q, start_address_validation(), suggest_to_connect(), and uri.

Referenced by handle_hello_for_client().

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

◆ handle_hello_for_client()

static void handle_hello_for_client ( void *  cls,
const struct GNUNET_PEERSTORE_Record record,
const char *  emsg 
)
static

Function called by PEERSTORE for each matching record.

Parameters
clsclosure, a struct PeerRequest
recordpeerstore record information
emsgerror message, or NULL if no errors

Definition at line 12606 of file gnunet-service-transport.c.

12609{
12610 struct PeerRequest *pr = cls;
12612 struct GNUNET_MessageHeader *hello;
12613
12614 if (NULL != emsg)
12615 {
12617 "Got failure from PEERSTORE: %s\n",
12618 emsg);
12619 return;
12620 }
12621 hello = record->value;
12622 if (0 == GNUNET_memcmp (&record->peer, &GST_my_identity))
12623 {
12625 return;
12626 }
12630 NULL);
12632}
static void hello_for_client_cb(void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
struct GNUNET_PEERSTORE_Monitor * nc
Notify context for new HELLOs.

References GNUNET_ERROR_TYPE_WARNING, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_iterate(), GNUNET_log, GNUNET_memcmp, GNUNET_PEERSTORE_monitor_next(), GST_my_identity, hello_for_client_cb(), PeerRequest::nc, consensus-simulation::parser, PeerRequest::pr, and record().

Referenced by handle_suggest().

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

◆ hello_for_client_error_cb()

static void hello_for_client_error_cb ( void *  cls)
static

Definition at line 12636 of file gnunet-service-transport.c.

12637{
12639 "Error in PEERSTORE monitoring\n");
12640}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by handle_suggest().

Here is the caller graph for this function:

◆ hello_for_client_sync_cb()

static void hello_for_client_sync_cb ( void *  cls)
static

Definition at line 12644 of file gnunet-service-transport.c.

12645{
12647 "Done with initial PEERSTORE iteration during monitoring\n");
12648}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by handle_suggest().

Here is the caller graph for this function:

◆ handle_suggest()

static void handle_suggest ( void *  cls,
const struct ExpressPreferenceMessage msg 
)
static

We have received a struct ExpressPreferenceMessage from an application client.

Parameters
clshandle to the client
msgthe start message

Definition at line 12659 of file gnunet-service-transport.c.

12660{
12661 struct TransportClient *tc = cls;
12662 struct PeerRequest *pr;
12663
12664 if (CT_NONE == tc->type)
12665 {
12666 tc->type = CT_APPLICATION;
12667 tc->details.application.requests =
12669 }
12670 if (CT_APPLICATION != tc->type)
12671 {
12672 GNUNET_break (0);
12674 return;
12675 }
12677 "Client suggested we talk to %s with preference %d at rate %u\n",
12678 GNUNET_i2s (&msg->peer),
12679 (int) ntohl (msg->pk),
12680 (int) ntohl (msg->bw.value__));
12681 pr = GNUNET_new (struct PeerRequest);
12682 pr->tc = tc;
12683 pr->pid = msg->peer;
12684 pr->bw = msg->bw;
12685 pr->pk = ntohl (msg->pk);
12687 tc->details.application.requests,
12688 &pr->pid,
12689 pr,
12691 {
12692 GNUNET_break (0);
12693 GNUNET_free (pr);
12695 return;
12696 }
12697 pr->nc =
12699 GNUNET_YES,
12700 "peerstore",
12701 NULL,
12704 NULL,
12706 NULL,
12708 pr);
12710}
static void hello_for_client_error_cb(void *cls)
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.
static void hello_for_client_sync_cb(void *cls)

References CT_APPLICATION, CT_NONE, GNUNET_break, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, GST_cfg, handle_hello_for_client(), hello_for_client_error_cb(), hello_for_client_sync_cb(), msg, PeerRequest::pr, and tc.

Here is the call graph for this function:

◆ check_request_hello_validation()

static int check_request_hello_validation ( void *  cls,
const struct RequestHelloValidationMessage m 
)
static

Check GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION messages.

Parameters
clsa struct TransportClient *
mmessage to verify
Returns
GNUNET_OK on success

Definition at line 12722 of file gnunet-service-transport.c.

12724{
12725 (void) cls;
12727 return GNUNET_OK;
12728}
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:103

References GNUNET_MQ_check_zero_termination, GNUNET_OK, and m.

◆ handle_request_hello_validation()

static void handle_request_hello_validation ( void *  cls,
const struct RequestHelloValidationMessage m 
)
static

A client encountered an address of another peer.

Consider validating it, and if validation succeeds, persist it to PEERSTORE.

Parameters
clsa struct TransportClient *
mmessage to verify

Definition at line 12739 of file gnunet-service-transport.c.

12741{
12742 struct TransportClient *tc = cls;
12743 struct Queue *q;
12744
12745 q = find_queue (&m->peer, (const char *) &m[1]);
12746 if (NULL == q)
12747 {
12748 suggest_to_connect (&m->peer, (const char *) &m[1]);
12749 }
12750 else
12751 start_address_validation (&m->peer, (const char *) &m[1]);
12753}

References find_queue(), GNUNET_SERVICE_client_continue(), m, q, start_address_validation(), suggest_to_connect(), and tc.

Here is the call graph for this function:

◆ free_neighbour_cb()

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

Free neighbour entry.

Parameters
clsNULL
pidunused
valuea struct Neighbour
Returns
GNUNET_OK (always)

Definition at line 12765 of file gnunet-service-transport.c.

12768{
12769 struct Neighbour *neighbour = value;
12770
12771 (void) cls;
12772 (void) pid;
12773 GNUNET_break (0); // should this ever happen?
12774 free_neighbour (neighbour, GNUNET_YES);
12775
12776 return GNUNET_OK;
12777}

References free_neighbour(), GNUNET_break, GNUNET_OK, GNUNET_YES, pid, and value.

Referenced by do_shutdown().

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

◆ free_dv_routes_cb()

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

Free DV route entry.

Parameters
clsNULL
pidunused
valuea struct DistanceVector
Returns
GNUNET_OK (always)

Definition at line 12789 of file gnunet-service-transport.c.

12792{
12793 struct DistanceVector *dv = value;
12794
12795 (void) cls;
12796 (void) pid;
12797 free_dv_route (dv);
12798
12799 return GNUNET_OK;
12800}

References free_dv_route(), GNUNET_OK, pid, and value.

Referenced by do_shutdown().

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

◆ free_validation_state_cb()

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

Free validation state.

Parameters
clsNULL
pidunused
valuea struct ValidationState
Returns
GNUNET_OK (always)

Definition at line 12812 of file gnunet-service-transport.c.

12815{
12816 struct ValidationState *vs = value;
12817
12818 (void) cls;
12819 (void) pid;
12821 return GNUNET_OK;
12822}

References free_validation_state(), GNUNET_OK, pid, and value.

Referenced by do_shutdown().

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

◆ free_pending_ack_cb()

static int free_pending_ack_cb ( void *  cls,
const struct GNUNET_Uuid key,
void *  value 
)
static

Free pending acknowledgement.

Parameters
clsNULL
keyunused
valuea struct PendingAcknowledgement
Returns
GNUNET_OK (always)

Definition at line 12834 of file gnunet-service-transport.c.

12835{
12836 struct PendingAcknowledgement *pa = value;
12837
12838 (void) cls;
12839 (void) key;
12841 return GNUNET_OK;
12842}

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

Referenced by do_shutdown().

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

◆ free_ack_cummulator_cb()

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

Free acknowledgement cummulator.

Parameters
clsNULL
pidunused
valuea struct AcknowledgementCummulator
Returns
GNUNET_OK (always)

Definition at line 12854 of file gnunet-service-transport.c.

12857{
12858 struct AcknowledgementCummulator *ac = value;
12859
12860 (void) cls;
12861 (void) pid;
12863 GNUNET_free (ac);
12864 return GNUNET_OK;
12865}

References GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), pid, AcknowledgementCummulator::task, and value.

Referenced by do_shutdown().

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

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Definition at line 12965 of file gnunet-service-transport.c.

12966{
12968
12970 "Shutdown task executed\n");
12971 if (NULL != clients_head)
12972 {
12973 for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
12974 {
12976 "client still connected: %u\n",
12977 tc->type);
12978 }
12979 }
12980 else
12981 do_shutdown (cls);
12982
12983}

References clients_head, do_shutdown(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_YES, in_shutdown, and tc.

Referenced by run().

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

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Initiate transport service.

Parameters
clsclosure
cconfiguration to use
servicethe initialized service

Definition at line 12994 of file gnunet-service-transport.c.

12997{
12998 (void) cls;
12999 (void) service;
13000 /* setup globals */
13003 GST_cfg = c;
13011 GNUNET_YES);
13018 if (NULL == GST_my_private_key)
13019 {
13020 GNUNET_log (
13022 _ (
13023 "Transport service is lacking key configuration settings. Exiting.\n"));
13025 return;
13026 }
13030 "My identity is `%s'\n",
13034 "transport",
13035 "USE_BURST_NAT");
13036 if (GNUNET_SYSERR == use_burst)
13038 "Could not configure burst nat use. Default to no.\n");
13043 "transport",
13044 0,
13045 0,
13046 NULL,
13047 0,
13048 NULL,
13049 NULL,
13050 NULL);
13051 if (NULL == peerstore)
13052 {
13053 GNUNET_break (0);
13055 return;
13056 }
13057}
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void shutdown_task(void *cls)
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:201
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer's key from the file specified in the configuration.
struct GNUNET_CONTAINER_MultiUuidmap * GNUNET_CONTAINER_multiuuidmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_CONTAINER_MultiShortmap * GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
struct GNUNET_HELLO_Builder * GNUNET_HELLO_builder_new(const struct GNUNET_PeerIdentity *pid)
Allocate builder.
Definition: hello-uri.c:401
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_NAT_Handle * GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section, uint8_t proto, unsigned int num_addrs, const struct sockaddr **addrs, const socklen_t *addrlens, GNUNET_NAT_AddressCallback address_callback, GNUNET_NAT_ReversalCallback reversal_callback, void *callback_cls)
Attempt to enable port redirection and detect public IP address contacting UPnP or NAT-PMP routers on...
Definition: nat_api.c:366
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1339
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
#define _(String)
GNU gettext support macro.
Definition: platform.h:179

References _, ack_cummulators, backtalkers, dv_routes, dvlearn_map, GNUNET_break, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multiuuidmap_create(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_HELLO_builder_new(), GNUNET_i2s_full(), GNUNET_log, GNUNET_NAT_register(), GNUNET_NO, GNUNET_PEERSTORE_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_monotonic(), GNUNET_YES, GST_cfg, GST_my_hello, GST_my_identity, GST_my_private_key, GST_stats, hello_mono_time, in_shutdown, links, MAX_DV_LEARN_PENDING, neighbours, nh, peerstore, pending_acks, GNUNET_PeerIdentity::public_key, revalidation_map, service, shutdown_task(), use_burst, validation_heap, and validation_map.

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN ( GNUNET_OS_project_data_gnunet()  ,
"transport"  ,
GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN  ,
run,
client_connect_cb,
client_disconnect_cb,
NULL  ,
GNUNET_MQ_hd_fixed_size(suggest, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST, struct ExpressPreferenceMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(suggest_cancel, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL, struct ExpressPreferenceMessage, NULL)  ,
GNUNET_MQ_hd_var_size(request_hello_validation, GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION, struct RequestHelloValidationMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(client_start, GNUNET_MESSAGE_TYPE_TRANSPORT_START, struct StartMessage, NULL)  ,
GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, struct OutboundMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(client_recv_ok, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK, struct RecvOkMessage, NULL)  ,
GNUNET_MQ_hd_var_size(communicator_available, GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR, struct GNUNET_TRANSPORT_CommunicatorAvailableMessage, NULL)  ,
GNUNET_MQ_hd_var_size(communicator_backchannel, GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL, struct GNUNET_TRANSPORT_CommunicatorBackchannel, NULL)  ,
GNUNET_MQ_hd_var_size(add_address, GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS, struct GNUNET_TRANSPORT_AddAddressMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(del_address, GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS, struct GNUNET_TRANSPORT_DelAddressMessage, NULL)  ,
GNUNET_MQ_hd_var_size(incoming_msg, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG, struct GNUNET_TRANSPORT_IncomingMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(queue_create_ok, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK, struct GNUNET_TRANSPORT_CreateQueueResponse, NULL)  ,
GNUNET_MQ_hd_fixed_size(queue_create_fail, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL, struct GNUNET_TRANSPORT_CreateQueueResponse, NULL)  ,
GNUNET_MQ_hd_var_size(add_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP, struct GNUNET_TRANSPORT_AddQueueMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(update_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE, struct GNUNET_TRANSPORT_UpdateQueueMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(del_queue_message, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN, struct GNUNET_TRANSPORT_DelQueueMessage, NULL)  ,
GNUNET_MQ_hd_fixed_size(send_message_ack, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK, struct GNUNET_TRANSPORT_SendMessageToAck, NULL)  ,
GNUNET_MQ_hd_fixed_size(burst_finished, GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_FINISHED, struct GNUNET_TRANSPORT_BurstFinished, 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.

Variable Documentation

◆ ring_buffer

struct RingBufferEntry* ring_buffer[RING_BUFFER_SIZE]
static

Ring buffer for a CORE message we did not deliver to CORE, because of missing virtual link to sender.

Definition at line 2866 of file gnunet-service-transport.c.

Referenced by handle_raw_message(), and send_msg_from_cache().

◆ ring_buffer_head

unsigned int ring_buffer_head
static

Head of the ring buffer.

Definition at line 2871 of file gnunet-service-transport.c.

Referenced by handle_raw_message(), and send_msg_from_cache().

◆ is_ring_buffer_full

unsigned int is_ring_buffer_full
static

Is the ring buffer filled up to RING_BUFFER_SIZE.

Definition at line 2876 of file gnunet-service-transport.c.

Referenced by handle_raw_message(), and send_msg_from_cache().

◆ ring_buffer_dv

struct PendingMessage* ring_buffer_dv[RING_BUFFER_SIZE]
static

Ring buffer for a forwarded DVBox message we did not deliver to the next hop, because of missing virtual link that hop.

Definition at line 2881 of file gnunet-service-transport.c.

Referenced by forward_dv_box(), and send_msg_from_cache().

◆ ring_buffer_dv_head

unsigned int ring_buffer_dv_head
static

Head of the ring buffer.

Definition at line 2886 of file gnunet-service-transport.c.

Referenced by forward_dv_box(), and send_msg_from_cache().

◆ is_ring_buffer_dv_full

unsigned int is_ring_buffer_dv_full
static

Is the ring buffer filled up to RING_BUFFER_SIZE.

Definition at line 2891 of file gnunet-service-transport.c.

Referenced by forward_dv_box(), and send_msg_from_cache().

◆ clients_head

◆ clients_tail

struct TransportClient* clients_tail
static

Tail of linked list of all clients to this service.

Definition at line 2901 of file gnunet-service-transport.c.

Referenced by client_connect_cb(), and client_disconnect_cb().

◆ GST_stats

◆ GST_cfg

◆ GST_my_identity

◆ GST_my_hello

struct GNUNET_HELLO_Builder* GST_my_hello

Our HELLO.

Definition at line 2921 of file gnunet-service-transport.c.

Referenced by do_shutdown(), run(), and store_pi().

◆ GST_my_private_key

◆ neighbours

struct GNUNET_CONTAINER_MultiPeerMap* neighbours
static

Map from PIDs to struct Neighbour entries.

A peer is a neighbour if we have an MQ to it from some communicator.

Definition at line 2932 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_neighbour(), handle_add_queue_message(), handle_dv_learn(), handle_monitor_start(), lookup_neighbour(), run(), and start_dv_learn().

◆ backtalkers

struct GNUNET_CONTAINER_MultiPeerMap* backtalkers
static

Map from PIDs to struct Backtalker entries.

A peer is a backtalker if it recently send us backchannel messages.

Definition at line 2938 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_backtalker(), handle_dv_box(), and run().

◆ ack_cummulators

struct GNUNET_CONTAINER_MultiPeerMap* ack_cummulators
static

Map from PIDs to struct AcknowledgementCummulators.

Here we track the cumulative ACKs for transmission.

Definition at line 2944 of file gnunet-service-transport.c.

Referenced by cummulative_ack(), destroy_ack_cummulator(), do_shutdown(), and run().

◆ pending_acks

struct GNUNET_CONTAINER_MultiUuidmap* pending_acks
static

Map of pending acknowledgements, mapping struct AcknowledgementUUID to a struct PendingAcknowledgement.

Definition at line 2950 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_pending_acknowledgement(), handle_reliability_ack(), prepare_pending_acknowledgement(), and run().

◆ dv_routes

struct GNUNET_CONTAINER_MultiPeerMap* dv_routes
static

Map from PIDs to struct DistanceVector entries describing known paths to the peer.

Definition at line 2956 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_dv_route(), learn_dv_path(), route_control_message_without_fc(), and run().

◆ validation_map

struct GNUNET_CONTAINER_MultiPeerMap* validation_map
static

Map from PIDs to struct ValidationState entries describing addresses we are aware of and their validity state.

Definition at line 2962 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_validation_state(), handle_add_queue_message(), handle_validation_response(), run(), and start_address_validation().

◆ revalidation_map

struct GNUNET_CONTAINER_MultiHashMap* revalidation_map
static

Map from addresses to struct ValidationState entries describing addresses we are aware of and their validity state.

Definition at line 2968 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_validation_state(), handle_validation_response(), run(), and validation_transmit_on_queue().

◆ links

struct GNUNET_CONTAINER_MultiPeerMap* links
static

Map from PIDs to struct VirtualLink entries describing links CORE knows to exist.

Definition at line 2974 of file gnunet-service-transport.c.

Referenced by activate_core_visible_dv_path(), do_shutdown(), free_virtual_link(), handle_client_start(), handle_flow_control(), handle_validation_response(), lookup_virtual_link(), and run().

◆ dvlearn_map

struct GNUNET_CONTAINER_MultiShortmap* dvlearn_map
static

Map from challenges to struct LearnLaunchEntry values.

Definition at line 2979 of file gnunet-service-transport.c.

Referenced by do_shutdown(), run(), and start_dv_learn().

◆ lle_head

struct LearnLaunchEntry* lle_head = NULL
static

Head of a DLL sorted by launch time.

Definition at line 2984 of file gnunet-service-transport.c.

Referenced by do_shutdown(), and start_dv_learn().

◆ lle_tail

struct LearnLaunchEntry* lle_tail = NULL
static

Tail of a DLL sorted by launch time.

Definition at line 2989 of file gnunet-service-transport.c.

Referenced by do_shutdown(), and start_dv_learn().

◆ validation_heap

struct GNUNET_CONTAINER_Heap* validation_heap
static

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.

Definition at line 2996 of file gnunet-service-transport.c.

Referenced by do_shutdown(), run(), update_next_challenge_time(), and validation_start_cb().

◆ nh

◆ peerstore

◆ dvlearn_task

struct GNUNET_SCHEDULER_Task* dvlearn_task
static

Task run to initiate DV learning.

Definition at line 3011 of file gnunet-service-transport.c.

Referenced by do_shutdown(), handle_add_queue_message(), and start_dv_learn().

◆ validation_task

struct GNUNET_SCHEDULER_Task* validation_task
static

Task to run address validation.

Definition at line 3016 of file gnunet-service-transport.c.

Referenced by do_shutdown(), update_next_challenge_time(), and validation_start_cb().

◆ ir_head

struct IncomingRequest* ir_head
static

List of incoming connections where we are trying to get a connection back established.

Length kept in ir_total.

Definition at line 3023 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_incoming_request(), and handle_validation_challenge().

◆ ir_tail

struct IncomingRequest* ir_tail
static

Tail of DLL starting at ir_head.

Definition at line 3028 of file gnunet-service-transport.c.

Referenced by free_incoming_request(), and handle_validation_challenge().

◆ ir_total

unsigned int ir_total
static

Length of the DLL starting at ir_head.

Definition at line 3033 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_incoming_request(), and handle_validation_challenge().

◆ logging_uuid_gen

unsigned long long logging_uuid_gen
static

Generator of logging_uuid in struct PendingMessage.

Definition at line 3038 of file gnunet-service-transport.c.

Referenced by extract_box_cb(), forward_dv_box(), fragment_message(), handle_client_send(), and reliability_box_message().

◆ burst_running

enum GNUNET_GenericReturnValue burst_running
static

Is there a burst running?

Definition at line 3043 of file gnunet-service-transport.c.

Referenced by burst_timeout(), handle_burst_finished(), queue_burst(), and start_burst().

◆ hello_mono_time

struct GNUNET_TIME_Absolute hello_mono_time
static

Monotonic time we use for HELLOs generated at this time.

TODO: we should increase this value from time to time (i.e. whenever a struct AddressListEntry actually expires), but IF we do this, we must also update all (remaining) addresses in the PEERSTORE at that time! (So for now only increased when the peer is restarted, which hopefully roughly matches whenever our addresses change.)

Definition at line 3053 of file gnunet-service-transport.c.

Referenced by run(), and store_pi().

◆ in_shutdown

int in_shutdown
static

Indication if we have received a shutdown signal and are in the process of cleaning up.

Definition at line 3059 of file gnunet-service-transport.c.

Referenced by client_disconnect_cb(), run(), and shutdown_task().

◆ burst_task

struct GNUNET_SCHEDULER_Task* burst_task
static

The task to start the burst.

Definition at line 3064 of file gnunet-service-transport.c.

Referenced by queue_burst(), and start_burst().

◆ burst_timeout_task

struct GNUNET_SCHEDULER_Task* burst_timeout_task

Definition at line 3066 of file gnunet-service-transport.c.

Referenced by start_burst().

◆ use_burst

enum GNUNET_GenericReturnValue use_burst

Definition at line 3068 of file gnunet-service-transport.c.

Referenced by queue_burst(), and run().