gnunet-service-transport.c File Reference

main for gnunet-service-transport More...

#include "platform.h"
#include "gnunet_common.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_peerstore_service.h"
#include "gnunet_pils_service.h"
#include "gnunet_transport_communication_service.h"
#include "gnunet_nat_service.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_signatures.h"
#include "transport.h"

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	PilsRequest
	DLL. More...
struct	MonitorEvent
	Details about what to notify monitors about. More...
struct	AddGlobalAddressesContext
struct	PilsAddressSignContext
	Helper context struct for HELLO update. More...
struct	SignedAddress
	Binary block we sign when we sign an address. More...
struct	FindByMessageUuidContext
	Closure for find_by_message_uuid. More...
struct	NeighbourSelectionContext
	Closure for dv_neighbour_selection and dv_neighbour_transmission. More...
struct	CheckKnownAddressContext
	Closure for check_known_address. More...
struct	CheckKnownChallengeContext
	Closure for check_known_challenge. More...
struct	PendingMessageScoreContext
	Context for select_best_pending_from_link(). More...
struct	LinkListContext
	Closure for report_link(). More...
struct	QueueQualityContext
	Closure for check_connection_quality. More...
struct	TransportGlobalNattedAddressClosure
struct	UpdateHelloFromPidCtx

Macros
#define	RING_BUFFER_SIZE   16
	Size of ring buffer to cache CORE and forwarded DVBox messages.
#define	MAX_FC_RETRANSMIT_COUNT   1000
	Maximum number of FC retransmissions for a running retransmission task.
#define	MIN_FC_RETRANSMIT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100)
	Lower bound on the delay between two flow control transmissions on the same virtual link.
#define	UNCONFIRMED_LINK_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
	How long do we keep a virtual link that only exists because some peer sent us a FLOW_CONTROL message, without it ever becoming confirmed?
#define	MAX_CUMMULATIVE_ACKS   64
	Maximum number of messages we acknowledge together in one cumulative ACK.
#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.
#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?
#define	GOODPUT_AGING_SLOTS   4
	Number of slots we keep of historic data for computation of goodput / message loss ratio.
#define	DEFAULT_WINDOW_SIZE   (128 * 1024)
	How big is the flow control window size by default; limits per-neighbour RAM utilization.
#define	MAX_INCOMING_REQUEST   16
	For how many incoming connections do we try to create a virtual link for (at the same time!).
#define	MAX_DV_DISCOVERY_SELECTION   16
	Maximum number of peers we select for forwarding DVInit messages at the same time (excluding initiator).
#define	RECV_WINDOW_SIZE   4
	Window size.
#define	CORE_FC_STALL_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
	How long do we wait for CORE to return the flow control credit for the messages we handed it before we give up on them?
#define	MAX_STALLED_CMCS   (4 * RECV_WINDOW_SIZE)
	How many messages may wait on VirtualLink::core_recv_window before we stop deferring their flow control ACKs?
#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?
#define	MAX_DV_HOPS_ALLOWED   16
	Maximum DV distance allowed ever.
#define	MAX_DV_PICK_TRIES   1000
	How often pick_random_dv_hops() may redraw before settling for the paths it has.
#define	MAX_DV_LEARN_PENDING   64
	Maximum number of DV learning activities we may have pending at the same time.
#define	MAX_DV_PATHS_TO_TARGET   3
	Maximum number of DV paths we keep simultaneously to the same target.
#define	PILS_FEED_ADDRESSES_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3)
	Delay between added/removed addresses and PILS feed call.
#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.
#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.
#define	DEFAULT_ACK_WAIT_DURATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
	Default value for how long we wait for reliability ack.
#define	MIN_ACK_WAIT_DURATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 10)
	Lower bound on the RTT estimate we are willing to derive a retransmission deadline from.
#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.
#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!
#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?
#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.
#define	EPHEMERAL_VALIDITY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
	How long are ephemeral keys valid?
#define	REASSEMBLY_EXPIRATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)
	How long do we keep partially reassembled messages around before giving up?
#define	MAX_REASSEMBLY_CONTEXTS   32
	Maximum number of messages we are willing to reassemble in parallel for a single virtual link.
#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.)?
#define	MAX_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1)
	What is the slowest rate at which we send challenges?
#define	WANTED_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
	What is the slowest rate at which we send challenges to a peer that an application client explicitly asked for and that we have no confirmed link to? Somebody is waiting for this one, so a day is not an option.
#define	SUGGEST_RETRY_MIN    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
	How soon after an application asked us for a peer do we retry bringing the link up for the first time?
#define	SUGGEST_RETRY_MAX    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
	What is the slowest rate at which we retry bringing up a link that an application client explicitly asked for? Unlike a peer we merely heard about, somebody is waiting for this one, so this is far below MAX_VALIDATION_CHALLENGE_FREQ.
#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.
#define	DV_LEARN_BASE_FREQUENCY   GNUNET_TIME_UNIT_MINUTES
	What is the non-randomized base frequency at which we would initiate DV learn messages?
#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?
#define	MAX_ADDRESS_VALID_UNTIL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1)
	When do we forget an invalid address for sure?
#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?
#define	NEIGHBOUR_LIVENESS_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
	How long may a direct neighbour stay completely silent before we stop believing that its queues work, regardless of what the communicator that owns them tells us?
#define	FC_KEEPALIVE_INTERVAL
	How long may a confirmed virtual link go without us sending anything on it before we transmit an otherwise unnecessary FLOW_CONTROL message, purely so that the peer at the other end keeps seeing traffic from us?
#define	MIN_ADDRESS_REFRESH_INTERVAL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
	How often are we willing to re-sign and re-store one of our own addresses in PEERSTORE, no matter how short a lifetime the communicator that owns it claims? See peerstore_store_own_cb().
#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).
#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).
#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?
#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?
#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.
#define	SHUTDOWN_CLIENT_GRACE_PERIOD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
	How long do we wait during shutdown for our clients to disconnect on their own before we drop them? We run with GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, so nobody drops them for us and a single wedged client would otherwise keep us alive forever.

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.

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
GNUNET_NETWORK_STRUCT_END	GNUNET_static_assert (sizeof(struct TransportGlobalNattedAddress)==4)
	GNUNET_static_assert (sizeof(struct TransportFlowControlMessage)==60)
	GNUNET_static_assert (sizeof(struct TransportDVBoxMessage)==86)
	GNUNET_static_assert (sizeof(struct TransportDVLearnMessage)==152)
	GNUNET_static_assert (sizeof(struct TransportFragmentBoxMessage)==32)
	GNUNET_static_assert (sizeof(struct TransportReliabilityBoxMessage)==24)
	GNUNET_static_assert (sizeof(struct TransportReliabilityAckMessage)==8)
	GNUNET_static_assert (sizeof(struct TransportValidationChallengeMessage)==48)
	GNUNET_static_assert (sizeof(struct TransportValidationResponseMessage)==120)
static enum GNUNET_GenericReturnValue	sign_by_my_identity (const struct GNUNET_CRYPTO_SignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
	Sign purpose with the private key of our current peer identity.
static unsigned int	get_age ()
	Get an offset into the transmission history buffer for struct PerformanceData.
static void	free_incoming_request (struct IncomingRequest *ir)
	Release ir data structure.
static void	free_pending_acknowledgement (struct PendingAcknowledgement *pa)
	Release pa data structure.
static void	free_fragment_tree (struct PendingMessage *root)
	Free fragment tree below root, excluding root itself.
static void	free_pending_message (struct PendingMessage *pm)
	Release memory associated with pm and remove pm from associated data structures.
static void	free_reassembly_context (struct ReassemblyContext *rc)
	Free rc.
static void	reassembly_cleanup_task (void *cls)
	Task run to clean up reassembly context of a neighbour that have expired.
static int	free_reassembly_cb (void *cls, uint32_t key, void *value)
	function called to free_reassembly_context().
static void	finish_cmc_handling_with_continue (struct CommunicatorMessageContext *cmc, unsigned int free_cmc)
	Send ACK to communicator (if requested) and free cmc.
static void	release_stalled_cmc (struct VirtualLink *vl, struct CommunicatorMessageContext *cmc)
	Take cmc off the list of messages waiting on vl's CORE receive window, release the flow control credit we were withholding and free it.
static void	free_burst_cls (struct GNUNET_StartBurstCls *sb_cls)
	Release a burst closure, detaching it from its virtual link and from the scheduled burst_task (if that is the task the closure belongs to).
static void	send_ok_to_client (struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
	Return one unit of send window credit for pid to tc.
static void	credit_client (struct PendingMessage *pm)
	Return the send window credit that pm's client is owed, at most once for pm.
static void	free_virtual_link (struct VirtualLink *vl)
	Free virtual link.
static void	free_validation_state (struct ValidationState *vs)
	Free validation state.
static struct Neighbour *	lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
	Lookup neighbour for peer pid.
static struct VirtualLink *	lookup_virtual_link (const struct GNUNET_PeerIdentity *pid)
	Lookup virtual link for peer pid.
static void	free_distance_vector_hop (struct DistanceVectorHop *dvh)
	Free a dvh.
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.
static void	cores_send_disconnect_info (const struct GNUNET_PeerIdentity *pid)
	Send message to CORE clients that we lost a connection.
static void	try_to_bring_link_up (const struct GNUNET_PeerIdentity *pid)
	Ask for everything that could give us a confirmed virtual link to pid: revalidate the addresses we already track, then those of the queues we still have, and failing both look for one in PEERSTORE.
static void	disconnect_and_free_virtual_link (struct VirtualLink *vl)
	Tell CORE clients the link to vl is gone, then release it.
static void	free_dv_route (struct DistanceVector *dv)
	Free entry in dv_routes.
static void	notify_monitor (struct TransportClient *tc, const struct GNUNET_PeerIdentity *peer, const char *address, enum GNUNET_NetworkType nt, const struct MonitorEvent *me)
	Notify monitor tc about an event.
static 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 void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Called whenever a client connects.
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.
static void	core_send_connect_info (struct TransportClient *tc, const struct GNUNET_PeerIdentity *pid)
	Send message to CORE clients that we lost a connection.
static void	cores_send_connect_info (const struct GNUNET_PeerIdentity *pid)
	Send message to CORE clients that we gained a connection.
static void	transmit_on_queue (void *cls)
	We believe we are ready to transmit a message on a queue.
static unsigned int	check_for_queue_with_higher_prio (struct Queue *queue, struct Queue *queue_head)
	Check if there is another queue to the same neighbour, over a different communicator, that has a higher priority and is ready for sending.
static void	arm_free_queue_entry_task (struct TransportClient *tc)
	Make sure free_timedout_queue_entry() will run for tc, so that `struct QueueEntry's the communicator never acknowledged are reclaimed.
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().
static void	start_address_validation (const struct GNUNET_PeerIdentity *pid, const char *address)
	Start address validation.
static void	free_queue (struct Queue *queue)
	Free queue.
static void	cancel_address_store (struct AddressListEntry *ale)
	Abort the asynchronous sign-and-store chain (if any) that is currently running for ale and release its context.
static void	free_address_list_entry (struct AddressListEntry *ale)
	Free ale.
static int	stop_peer_request (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Stop the peer request in value.
static void	do_shutdown (void *cls)
	Function called when the service shuts down.
static enum GNUNET_GenericReturnValue	detach_cmcs_from_link (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Detach the `struct CommunicatorMessageContext's parked on value from the client in cls.
static enum GNUNET_GenericReturnValue	detach_cmc_from_backtalker (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Detach the ‘struct CommunicatorMessageContext’ parked on value from the client in cls.
static void	detach_cmcs_from_client (const struct TransportClient *tc)
	A communicator client is going away.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Called whenever a client is disconnected.
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.
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.
static int	check_client_send (void *cls, const struct OutboundMessage *obm)
	Client asked for transmission to a peer.
static void	client_send_response (struct PendingMessage *pm)
	Send a response to the pm that we have processed a "send" request.
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 int	check_communicator_available (void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
	Communicator started.
static void	send_cmc_ack (struct CommunicatorMessageContext *cmc)
	Release the CORE flow control credit for cmc by acknowledging the message to the communicator that delivered it.
static void	resume_cmc_client (struct CommunicatorMessageContext *cmc)
	Let the communicator that delivered cmc give us its next message.
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.
static void	handle_communicator_available (void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
	Communicator started.
static int	check_communicator_backchannel (void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
	Communicator requests backchannel transmission.
static enum GNUNET_GenericReturnValue	sign_ephemeral (struct DistanceVector *dv)
	Sign the ephemeral key in dv, and mark it current.
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.
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.
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	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 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 void	consider_sending_fc (void *cls)
	Something changed on the virtual link with respect to flow control.
static void	task_consider_sending_fc (void *cls)
	Something changed on the virtual link with respect to flow control.
static char *	get_address_without_port (const char *address)
	Get the IP address without the communicator prefix and the port number.
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.
static void	handle_client_send (void *cls, const struct OutboundMessage *obm)
	Client asked for transmission to a peer.
static void	handle_communicator_backchannel (void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
	Communicator requests backchannel transmission.
static int	check_add_address (void *cls, const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
	Address of our peer added.
static void	store_pi (void *cls)
	Ask peerstore to store our address.
static void	shc_cont (void *cls, int success)
static void	pils_sign_hello_cb (void *cls, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig)
	Get HELLO signature and create message to store in PEERSTORE.
static void	peerstore_store_own_cb (void *cls, int success)
	Function called when peerstore is done storing our address.
static void	store_signed_address (struct PilsAddressSignContext *pc, const struct GNUNET_PeerIdentity *pid, const struct GNUNET_CRYPTO_EddsaSignature *sig)
	Turn the signed address into a HELLO URI and hand it to PEERSTORE.
void	pils_sign_address (struct AddressListEntry *ale, struct GNUNET_TIME_Absolute mono_time)
	Build address record by signing raw information with private key of the peer identity.
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 void	feed_addresses_to_pils (void *cls)
static void	handle_add_address (void *cls, const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
	Address of our peer added.
static void	handle_del_address (void *cls, const struct GNUNET_TRANSPORT_DelAddressMessage *dam)
	Address of our peer deleted.
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.
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.
static void	core_fc_stalled (void *cls)
	CORE never returned the flow control credit for the messages we handed it for cls, so the communicators that delivered them are still waiting on us.
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.
static int	check_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
	Communicator gave us a fragment box.
static void	destroy_ack_cummulator (void *cls)
	Clean up an idle cumulative acknowledgement data structure.
static void	transmit_cummulative_ack_cb (void *cls)
	Do the transmission of a cumulative acknowledgement now.
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.
static void	handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
	Communicator gave us a fragment.
static int	check_reliability_box (void *cls, const struct TransportReliabilityBoxMessage *rb)
	Communicator gave us a reliability box.
static void	handle_reliability_box (void *cls, const struct TransportReliabilityBoxMessage *rb)
	Communicator gave us a reliability box.
static void	update_pd_age (struct PerformanceData *pd, unsigned int age)
	Check if we have advanced to another age since the last time.
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.
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.
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	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).
static void	handle_acknowledged (struct PendingAcknowledgement *pa, struct GNUNET_TIME_Relative ack_delay)
	The pa was acknowledged, process the acknowledgement.
static int	check_reliability_ack (void *cls, const struct TransportReliabilityAckMessage *ra)
	Communicator gave us a reliability ack.
static void	handle_reliability_ack (void *cls, const struct TransportReliabilityAckMessage *ra)
	Communicator gave us a reliability ack.
static int	check_backchannel_encapsulation (void *cls, const struct TransportBackchannelEncapsulationMessage *be)
	Communicator gave us a backchannel encapsulation.
static void	handle_backchannel_encapsulation (void *cls, const struct TransportBackchannelEncapsulationMessage *be)
	Communicator gave us a backchannel encapsulation.
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.
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.
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).
static int	check_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
	Communicator gave us a DV learn message.
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.
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.
static int	dv_neighbour_selection (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Function called for each neighbour during handle_dv_learn.
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 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.
static void	neighbour_store_dvmono_cb (void *cls, int success)
	Function called when peerstore is done storing a DV monotonic time.
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.
static int	check_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
	Communicator gave us a 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)
	Create a DV Box message and queue it for transmission to next_hop.
static void	free_backtalker (struct Backtalker *b)
	Free data structures associated with b.
static int	free_backtalker_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Callback to free backtalker records.
static void	backtalker_timeout_cb (void *cls)
	Function called when it is time to clean up a backtalker.
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	backtalker_monotime_store_cb (void *cls, int success)
	Function called by PEERSTORE when the store operation of a backtalker's monotonic time is complete.
static void	update_backtalker_monotime (struct Backtalker *b)
	The backtalker b monotonic time changed.
static void	decaps_dv_box_cont (struct CommunicatorMessageContext *cmc, const struct TransportDVBoxMessage *dvb, const struct GNUNET_ShortHashCode *km)
	Open the DV box dvb addressed to us, using the key material km decapsulated from its ephemeral key.
static void	handle_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
	Communicator gave us a DV box.
static int	check_incoming_msg (void *cls, const struct GNUNET_TRANSPORT_IncomingMessage *im)
	Client notified us about transmission from a peer.
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.
static void	validation_start_cb (void *cls)
	Task run periodically to validate some address based on validation_heap.
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	speed_up_challenge (struct ValidationState *vs)
	Speed the next challenge for vs up because we heard something about that address again – but never faster than FAST_VALIDATION_CHALLENGE_FREQ.
static enum GNUNET_GenericReturnValue	revalidate_now_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Pull value's next challenge forward: the link to that peer is not up.
static struct Queue *	find_queue (const struct GNUNET_PeerIdentity *pid, const char *address)
	Find the queue matching pid and address.
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.
static void	hello_for_incoming_cb (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
static const struct GNUNET_MessageHeader *	hello_from_record (const struct GNUNET_PEERSTORE_Record *record)
	Obtain the HELLO message stored in record, if record actually carries one.
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.
static void	hello_for_incoming_error_cb (void *cls)
static void	hello_for_incoming_sync_cb (void *cls)
static void	send_t_validation_response (struct CommunicatorMessageContext *cmc, struct TransportValidationResponseMessage tvr)
	Route the signed validation response tvr back to the challenger and release cmc.
static void	handle_validation_challenge (void *cls, const struct TransportValidationChallengeMessage *tvc)
	Communicator gave us a transport address validation challenge.
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	peerstore_store_validation_cb (void *cls, int success)
	Function called when peerstore is done storing a validated address.
static struct Queue *	find_queue_by_ip (const struct GNUNET_PeerIdentity *pid, const char *address)
	Find a queue to pid whose address has the same IP as address, but possibly a different port.
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.
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.
static void	handle_incoming_msg (void *cls, const struct GNUNET_TRANSPORT_IncomingMessage *im)
	Incoming message.
static int	check_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
	Communicator gave us a transport address validation response.
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	unconfirmed_link_timeout (void *cls)
	Discard a virtual link that only ever existed because some peer sent us a FLOW_CONTROL message and that never became confirmed.
static void	handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
	Communicator gave us a transport address validation response.
static int	check_add_queue_message (void *cls, const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
	New queue became available.
static void	set_pending_message_uuid (struct PendingMessage *pm)
	If necessary, generates the UUID for a pm.
static struct PendingAcknowledgement *	prepare_pending_acknowledgement (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
	Setup data structure waiting for acknowledgements.
static struct PendingMessage *	fragment_message (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
	Fragment the given pm to the given mtu.
static struct PendingMessage *	reliability_box_message (struct Queue *queue, struct DistanceVectorHop *dvh, struct PendingMessage *pm)
	Reliability-box the given pm.
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.
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	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.
static void	handle_del_queue_message (void *cls, const struct GNUNET_TRANSPORT_DelQueueMessage *dqm)
	Queue to a peer went down.
static void	handle_send_message_ack (void *cls, const struct GNUNET_TRANSPORT_SendMessageToAck *sma)
	Message was transmitted.
static void	handle_burst_finished (void *cls, const struct GNUNET_TRANSPORT_BurstFinished *bf)
	The burst finished.
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.
static void	handle_monitor_start (void *cls, const struct GNUNET_TRANSPORT_MonitorStart *start)
	Initialize a monitor client.
static char *	communicator_list (struct Neighbour *n, unsigned int *num_queues)
	Build the 0-terminated, comma-separated list of address prefixes of the communicators that own the queues of n, without repeats.
static enum GNUNET_GenericReturnValue	report_link (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Send the state of the virtual link value to the requesting client.
static void	handle_link_list_request (void *cls, const struct GNUNET_TRANSPORT_LinkListRequest *lr)
	A client asks for the virtual links we currently have.
static struct TransportClient *	lookup_communicator (const char *prefix)
	Find transport client providing communication service for the protocol prefix.
static struct GNUNET_TIME_Relative	validation_challenge_freq (const struct GNUNET_PeerIdentity *pid)
	How slow are we allowed to get with challenges for pid?
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.
static void	start_dv_learn (void *cls)
	Task run when we CONSIDER initiating a DV learn process.
static void	transmit_dv_init (struct TransportDVLearnMessage dvl, struct LearnLaunchEntry *lle, struct QueueQualityContext qqc)
	Finish and transmit the DV learn message dvl we initiated.
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	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.
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.
static void	handle_update_queue_message (void *cls, const struct GNUNET_TRANSPORT_UpdateQueueMessage *msg)
	Handle updates to queues.
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.
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.
static void	handle_suggest_cancel (void *cls, const struct ExpressPreferenceMessage *msg)
	An application client no longer wants us to connect to a peer it asked for earlier.
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.
static void	hello_for_client_error_cb (void *cls)
static void	hello_for_client_sync_cb (void *cls)
static void	start_peer_request_monitor (struct PeerRequest *pr)
	(Re)start the PEERSTORE HELLO monitor of pr.
static void	suggest_retry_cb (void *cls)
	Task run for as long as an application client wants a link to pid that we do not have.
static void	handle_suggest (void *cls, const struct ExpressPreferenceMessage *msg)
	We have received a struct ExpressPreferenceMessage from an application client.
static int	check_request_hello_validation (void *cls, const struct RequestHelloValidationMessage *m)
	Check GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION messages.
static void	handle_request_hello_validation (void *cls, const struct RequestHelloValidationMessage *m)
	A client encountered an address of another peer.
static int	free_neighbour_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Free neighbour entry.
static int	free_virtual_link_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Free virtual link entry.
static int	free_dv_routes_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Free DV route entry.
static int	free_validation_state_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Free validation state.
static int	free_pending_ack_cb (void *cls, const struct GNUNET_Uuid *key, void *value)
	Free pending acknowledgement.
static int	free_ack_cummulator_cb (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
	Free acknowledgement cummulator.
static const char *	get_client_type_name (enum ClientType type)
static void	drop_remaining_clients (void *cls)
	The grace period we gave our clients to disconnect on their own expired.
static void	shutdown_task (void *cls)
static void	update_hello_from_pid_change_cb (void *cls, int success)
void	print_address_list (void *cls, const struct GNUNET_PeerIdentity *pid, const char *uri)
static void	pils_pid_change_cb (void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *hash)
	Callback called when pils service updates us with our new peer identity.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Initiate transport service.
	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_hd_fixed_size(link_list_request, GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_REQUEST, struct GNUNET_TRANSPORT_LinkListRequest, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
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.
static unsigned int	ring_buffer_head
	Head of the ring buffer.
static unsigned int	is_ring_buffer_full
	Is the ring buffer filled up to RING_BUFFER_SIZE.
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 virtual link that hop.
static unsigned int	ring_buffer_dv_head
	Head of the ring buffer.
static unsigned int	is_ring_buffer_dv_full
	Is the ring buffer filled up to RING_BUFFER_SIZE.
static struct TransportClient *	clients_head
	Head of linked list of all clients to this service.
static struct TransportClient *	clients_tail
	Tail of linked list of all clients to this service.
static struct GNUNET_STATISTICS_Handle *	GST_stats
	Statistics handle.
static const struct GNUNET_CONFIGURATION_Handle *	GST_cfg
	Configuration handle.
static struct GNUNET_SERVICE_Handle *	GST_service
	Our service handle; needed to force-disconnect clients that did not go away within SHUTDOWN_CLIENT_GRACE_PERIOD, as we use GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN.
static struct GNUNET_SCHEDULER_Task *	client_grace_task
	Task run when SHUTDOWN_CLIENT_GRACE_PERIOD expired and clients are still connected, or NULL.
struct GNUNET_HELLO_Builder *	GST_my_hello
	Our HELLO.
static struct GNUNET_CONTAINER_MultiPeerMap *	neighbours
	Map from PIDs to struct Neighbour entries.
static struct GNUNET_CONTAINER_MultiPeerMap *	backtalkers
	Map from PIDs to struct Backtalker entries.
static struct GNUNET_CONTAINER_MultiPeerMap *	ack_cummulators
	Map from PIDs to struct AcknowledgementCummulators.
static struct GNUNET_CONTAINER_MultiUuidmap *	pending_acks
	Map of pending acknowledgements, mapping struct AcknowledgementUUID to a struct PendingAcknowledgement.
static struct GNUNET_CONTAINER_MultiPeerMap *	dv_routes
	Map from PIDs to struct DistanceVector entries describing known paths to the peer.
static struct GNUNET_CONTAINER_MultiPeerMap *	validation_map
	Map from PIDs to struct ValidationState entries describing addresses we are aware of and their validity state.
static struct GNUNET_CONTAINER_MultiHashMap *	revalidation_map
	Map from addresses to struct ValidationState entries describing addresses we are aware of and their validity state.
static struct GNUNET_CONTAINER_MultiPeerMap *	links
	Map from PIDs to struct VirtualLink entries describing links CORE knows to exist.
static struct GNUNET_CONTAINER_MultiShortmap *	dvlearn_map
	Map from challenges to struct LearnLaunchEntry values.
static struct LearnLaunchEntry *	lle_head = NULL
	Head of a DLL sorted by launch time.
static struct LearnLaunchEntry *	lle_tail = NULL
	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 of by when we should next try to (re)validate (or expire) them.
struct GNUNET_NAT_Handle *	nh
	Handle for connect to the NAT service.
static struct GNUNET_PEERSTORE_Handle *	peerstore
	Database for peer's HELLOs.
static struct GNUNET_PILS_Handle *	pils
	Service that manages our peer id.
static struct PilsRequest *	pils_requests_head
	PILS Operation DLL.
static struct PilsRequest *	pils_requests_tail
	PILS Operation DLL.
static struct GNUNET_SCHEDULER_Task *	dvlearn_task
	Task run to initiate DV learning.
static struct GNUNET_TIME_Relative	dvlearn_pils_backoff
	Backoff for start_dv_learn() while PILS still owes us an identity.
static struct GNUNET_SCHEDULER_Task *	validation_task
	Task to run address validation.
static struct GNUNET_SCHEDULER_Task *	pils_feed_task
	Task to feed addresses to PILS.
static struct IncomingRequest *	ir_head
	List of incoming connections where we are trying to get a connection back established.
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 unsigned long long	logging_uuid_gen
	Generator of logging_uuid in struct PendingMessage.
static enum GNUNET_GenericReturnValue	burst_running
	Is there a burst running?
static struct GNUNET_TIME_Absolute	hello_mono_time
	Monotonic time we use for HELLOs generated at this time.
static int	in_shutdown
	Indication if we have received a shutdown signal and are in the process of cleaning up.
static struct GNUNET_SCHEDULER_Task *	burst_task
	The task to start the burst.
static struct GNUNET_StartBurstCls *	burst_task_cls
	Closure of the currently scheduled burst_task, or NULL.
struct GNUNET_SCHEDULER_Task *	burst_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 90 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 95 of file gnunet-service-transport.c.

MIN_FC_RETRANSMIT_DELAY

#define MIN_FC_RETRANSMIT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100)

Lower bound on the delay between two flow control transmissions on the same virtual link.

Without this an RTT estimate of zero turns consider_sending_fc() into a tight loop.

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

{
  uint64_t uuid GNUNET_PACKED;
};
 
 
struct AcknowledgementUUIDP
{
  struct GNUNET_Uuid value;
};
 
struct TransportBackchannelEncapsulationMessage
{
  struct GNUNET_MessageHeader header;
 
  /* Followed by *another* message header which is the message to
     the communicator */
 
  /* Followed by a 0-terminated name of the communicator */
};
 
 
struct EphemeralConfirmationPS
{
  struct GNUNET_CRYPTO_SignaturePurpose purpose;
 
  struct GNUNET_TIME_AbsoluteNBO sender_monotonic_time;
 
  struct GNUNET_PeerIdentity target;
 
  struct GNUNET_CRYPTO_HpkeEncapsulation ephemeral_key;
};
 
 
struct TransportDVBoxPayloadP
{
  struct GNUNET_PeerIdentity sender;
 
  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
 
  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
 
  /* Followed by a `struct GNUNET_MessageHeader` with a message
     for the target peer */
};
 
 
struct TransportReliabilityBoxMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t ack_countdown GNUNET_PACKED;
 
  struct AcknowledgementUUIDP ack_uuid;
};
 
 
struct TransportCummulativeAckPayloadP
{
  struct GNUNET_TIME_RelativeNBO ack_delay;
 
  struct AcknowledgementUUIDP ack_uuid;
};
 
 
struct TransportReliabilityAckMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t ack_counter GNUNET_PACKED;
 
  /* followed by any number of `struct TransportCummulativeAckPayloadP`
     messages providing ACKs */
};
 
 
struct TransportFragmentBoxMessage
{
  struct GNUNET_MessageHeader header;
 
  uint16_t frag_off GNUNET_PACKED;
 
  uint16_t msg_size GNUNET_PACKED;
 
  struct AcknowledgementUUIDP ack_uuid;
 
  struct MessageUUIDP msg_uuid;
};
 
 
struct DvInitPS
{
  struct GNUNET_CRYPTO_SignaturePurpose purpose;
 
  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
};
 
 
struct DvHopPS
{
  struct GNUNET_CRYPTO_SignaturePurpose purpose;
 
  struct GNUNET_PeerIdentity pred;
 
  struct GNUNET_PeerIdentity succ;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
};
 
 
struct DVPathEntryP
{
  struct GNUNET_PeerIdentity hop;
 
  struct GNUNET_CRYPTO_EddsaSignature hop_sig;
};
 
 
struct TransportDVLearnMessage
{
  struct GNUNET_MessageHeader header;
 
  uint16_t num_hops GNUNET_PACKED;
 
  uint16_t bidirectional GNUNET_PACKED;
 
  struct GNUNET_TIME_RelativeNBO non_network_delay;
 
  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
 
  struct GNUNET_CRYPTO_EddsaSignature init_sig;
 
  struct GNUNET_PeerIdentity initiator;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
 
  /* Followed by @e num_hops `struct DVPathEntryP` values,
     excluding the initiator of the DV trace; the last entry is the
     current sender; the current peer must not be included. */
};
 
 
struct TransportDVBoxMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t without_fc GNUNET_PACKED;
 
  uint16_t total_hops GNUNET_PACKED;
 
  uint16_t num_hops GNUNET_PACKED;
 
  struct GNUNET_CRYPTO_HpkeEncapsulation ephemeral_key;
 
  struct GNUNET_CRYPTO_AeadNonce iv;
 
  struct GNUNET_CRYPTO_AeadMac mac;
 
  uint16_t orig_size GNUNET_PACKED;
 
  /* Followed by @e num_hops `struct GNUNET_PeerIdentity` values;
     excluding the @e origin and the current peer, the last must be
     the ultimate target; if @e num_hops is zero, the receiver of this
     message is the ultimate target. */
 
  /* Followed by encrypted, variable-size payload, which
     must begin with a `struct TransportDVBoxPayloadP` */
 
  /* Followed by the actual message, which itself must not be a
     a DV_LEARN or DV_BOX message! */
};
 
 
struct TransportValidationChallengeMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t reserved GNUNET_PACKED;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
 
  struct GNUNET_TIME_AbsoluteNBO sender_time;
};
 
 
struct TransportValidationPS
{
  struct GNUNET_CRYPTO_SignaturePurpose purpose;
 
  struct GNUNET_TIME_RelativeNBO validity_duration;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
};
 
 
struct TransportValidationResponseMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t reserved GNUNET_PACKED;
 
  struct GNUNET_CRYPTO_EddsaSignature signature;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
 
  struct GNUNET_TIME_AbsoluteNBO origin_time;
 
  struct GNUNET_TIME_RelativeNBO validity_duration;
};
 
struct TransportGlobalNattedAddress
{
  uint32_t address_length GNUNET_PACKED;
 
  /* Followed by @e address_length bytes of the address. */
};
 
struct TransportFlowControlMessage
{
  struct GNUNET_MessageHeader header;
 
  uint32_t seq GNUNET_PACKED;
 
  uint64_t inbound_window_size GNUNET_PACKED;
 
  uint64_t outbound_sent GNUNET_PACKED;
 
  uint64_t outbound_window_size GNUNET_PACKED;
 
  struct GNUNET_TIME_AbsoluteNBO sender_time;
 
  struct GNUNET_TIME_RelativeNBO rtt;
 
  uint32_t sync_ready GNUNET_PACKED;
 
  uint32_t number_of_addresses GNUNET_PACKED;
 
  uint32_t size_of_addresses GNUNET_PACKED;
 
  /* Followed by @e number_of_addresses struct TransportGlobalNattedAddress. */
};
 
GNUNET_NETWORK_STRUCT_END
 
/* GNUNET_NETWORK_STRUCT_BEGIN/_END expand to nothing; only the per-member
   GNUNET_PACKED keeps these layouts free of compiler padding.  Pin the sizes
   so that adding an unpacked or non-fixed-width member cannot silently put
   padding bytes -- i.e. uninitialised stack -- on the wire again. */
GNUNET_static_assert (sizeof(struct TransportGlobalNattedAddress) == 4);
 
GNUNET_static_assert (sizeof(struct TransportFlowControlMessage) == 60);
GNUNET_static_assert (sizeof(struct TransportDVBoxMessage) == 86);
GNUNET_static_assert (sizeof(struct TransportDVLearnMessage) == 152);
GNUNET_static_assert (sizeof(struct TransportFragmentBoxMessage) == 32);
GNUNET_static_assert (sizeof(struct TransportReliabilityBoxMessage) == 24);
GNUNET_static_assert (sizeof(struct TransportReliabilityAckMessage) == 8);
GNUNET_static_assert (sizeof(struct TransportValidationChallengeMessage) == 48);
GNUNET_static_assert (sizeof(struct TransportValidationResponseMessage) == 120);
 
 
enum ClientType
{
  CT_NONE = 0,
 
  CT_CORE = 1,
 
  CT_MONITOR = 2,
 
  CT_COMMUNICATOR = 3,
 
  CT_APPLICATION = 4
};
 
 
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
};
 
 
struct LearnLaunchEntry
{
  struct LearnLaunchEntry *prev;
 
  struct LearnLaunchEntry *next;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
 
  struct GNUNET_TIME_Absolute launch_time;
};
 
 
struct TransmissionHistoryEntry
{
  uint64_t bytes_sent;
 
  uint64_t bytes_received;
};
 
 
struct PerformanceData
{
  struct GNUNET_TIME_Relative aged_rtt;
 
  struct TransmissionHistoryEntry the[GOODPUT_AGING_SLOTS];
 
  unsigned int last_age;
};
 
 
struct TransportClient;
 
struct Neighbour;
 
struct DistanceVector;
 
struct Queue;
 
struct PendingMessage;
 
struct DistanceVectorHop;
 
struct VirtualLink;
 
 
struct CommunicatorMessageContext
{
  struct CommunicatorMessageContext *next;
 
  struct CommunicatorMessageContext *prev;
 
  struct TransportClient *tc;
 
  struct GNUNET_TRANSPORT_IncomingMessage im;
 
  const struct GNUNET_MessageHeader *mh;
 
  uint16_t total_hops;
 
  unsigned int ack_sent;
 
  unsigned int client_resumed;
};
 
 
struct RingBufferEntry
{
  struct CommunicatorMessageContext *cmc;
 
  struct GNUNET_MessageHeader *mh;
};
 
 
struct CoreSentContext
{
  struct CoreSentContext *next;
 
  struct CoreSentContext *prev;
 
  struct VirtualLink *vl;
 
  uint16_t size;
 
  uint16_t isize;
};
 
 
struct ReassemblyContext
{
  struct MessageUUIDP msg_uuid;
 
  struct VirtualLink *virtual_link;
 
  struct GNUNET_CONTAINER_HeapNode *hn;
 
  uint8_t *bitfield;
 
  struct GNUNET_TIME_Absolute reassembly_timeout;
 
  struct GNUNET_TIME_Absolute last_frag;
 
  uint16_t msg_size;
 
  uint16_t msg_missing;
 
  /* Followed by @e msg_size bytes of the (partially) defragmented original
   * message */
 
  /* Followed by @e bitfield data */
};
 
 
struct VirtualLink
{
  struct GNUNET_PeerIdentity target;
 
  struct GNUNET_CONTAINER_MultiHashMap32 *reassembly_map;
 
  struct GNUNET_CONTAINER_Heap *reassembly_heap;
 
  struct GNUNET_SCHEDULER_Task *reassembly_timeout_task;
 
  struct CommunicatorMessageContext *cmc_head;
 
  struct CommunicatorMessageContext *cmc_tail;
 
  unsigned int cmc_count;
 
  struct GNUNET_SCHEDULER_Task *core_fc_stall_task;
 
  struct PendingMessage *pending_msg_head;
 
  struct PendingMessage *pending_msg_tail;
 
  struct CoreSentContext *csc_tail;
 
  struct CoreSentContext *csc_head;
 
  struct GNUNET_SCHEDULER_Task *visibility_task;
 
  struct GNUNET_SCHEDULER_Task *fc_retransmit_task;
 
  struct GNUNET_SCHEDULER_Task *unconfirmed_timeout_task;
 
  struct GNUNET_StartBurstCls *sb_cls;
 
  char *burst_addr;
 
  unsigned int fc_retransmit_count;
 
  unsigned int confirmed;
 
  struct Neighbour *n;
 
  struct DistanceVector *dv;
 
  struct GNUNET_TIME_Absolute n_challenge_time;
 
  struct GNUNET_TIME_Absolute last_fc_transmission;
 
  struct GNUNET_TIME_Absolute last_fc_timestamp;
 
  struct GNUNET_TIME_Relative last_fc_rtt;
 
  struct GNUNET_TIME_Relative other_rtt;
 
  struct GNUNET_PEERSTORE_IterateContext *ic;
 
  uint64_t message_uuid_ctr;
 
  uint64_t available_fc_window_size;
 
  uint64_t incoming_fc_window_size_ram;
 
  uint64_t incoming_fc_window_size;
 
  uint64_t incoming_fc_window_size_used;
 
  int64_t incoming_fc_window_size_loss;
 
  uint64_t outbound_fc_window_size;
 
  uint64_t outbound_fc_window_size_used;
 
  uint64_t last_outbound_window_size_received;
 
  uint32_t fc_seq_gen;
 
  uint32_t last_fc_seq;
 
  int core_recv_window;
 
  enum GNUNET_GenericReturnValue sync_ready;
};
 
 
struct PendingAcknowledgement
{
  struct PendingAcknowledgement *next_pm;
 
  struct PendingAcknowledgement *prev_pm;
 
  struct PendingAcknowledgement *next_queue;
 
  struct PendingAcknowledgement *prev_queue;
 
  struct PendingAcknowledgement *next_dvh;
 
  struct PendingAcknowledgement *prev_dvh;
 
  struct AcknowledgementUUIDP ack_uuid;
 
  struct PendingMessage *pm;
 
  struct DistanceVectorHop *dvh;
 
  struct Queue *queue;
 
  struct GNUNET_TIME_Absolute transmission_time;
 
  uint16_t message_size;
 
  unsigned int num_send;
};
 
 
struct DistanceVectorHop
{
  struct DistanceVectorHop *next_dv;
 
  struct DistanceVectorHop *prev_dv;
 
  struct DistanceVectorHop *next_neighbour;
 
  struct DistanceVectorHop *prev_neighbour;
 
  struct PendingAcknowledgement *pa_head;
 
  struct PendingAcknowledgement *pa_tail;
 
  struct Neighbour *next_hop;
 
  struct DistanceVector *dv;
 
  const struct GNUNET_PeerIdentity *path;
 
  struct GNUNET_TIME_Absolute timeout;
 
  struct GNUNET_TIME_Absolute path_valid_until;
 
  struct PerformanceData pd;
 
  unsigned int distance;
};
 
 
struct DistanceVector
{
  struct GNUNET_PeerIdentity target;
 
  struct DistanceVectorHop *dv_head;
 
  struct DistanceVectorHop *dv_tail;
 
  struct GNUNET_SCHEDULER_Task *timeout_task;
 
  struct VirtualLink *vl;
 
  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
 
  struct GNUNET_TIME_Absolute ephemeral_validity;
 
  struct GNUNET_TIME_Absolute monotime;
 
  struct GNUNET_CRYPTO_HpkeEncapsulation ephemeral_key;
 
  struct GNUNET_ShortHashCode *km;
};
 
 
struct QueueEntry
{
  struct QueueEntry *next;
 
  struct QueueEntry *prev;
 
  struct Queue *queue;
 
  struct PendingMessage *pm;
 
  uint64_t mid;
 
  struct GNUNET_TIME_Absolute creation_timestamp;
};
 
 
struct Queue
{
  struct Queue *next_neighbour;
 
  struct Queue *prev_neighbour;
 
  struct Queue *prev_client;
 
  struct Queue *next_client;
 
  struct PendingAcknowledgement *pa_head;
 
  struct PendingAcknowledgement *pa_tail;
 
  struct QueueEntry *queue_head;
 
  struct QueueEntry *queue_tail;
 
  struct Neighbour *neighbour;
 
  struct TransportClient *tc;
 
  const char *address;
 
  unsigned int unlimited_length;
 
  struct GNUNET_SCHEDULER_Task *transmit_task;
 
  struct GNUNET_TIME_Absolute validated_until;
 
  struct PerformanceData pd;
 
  struct GNUNET_PEERSTORE_Monitor *mo;
 
  uint64_t mid_gen;
 
  uint32_t qid;
 
  uint32_t mtu;
 
  uint32_t num_msg_pending;
 
  uint32_t num_bytes_pending;
 
  unsigned int queue_length;
 
  uint64_t q_capacity;
 
  uint32_t priority;
 
  enum GNUNET_NetworkType nt;
 
  enum GNUNET_TRANSPORT_ConnectionStatus cs;
 
  int idle;
 
  enum GNUNET_GenericReturnValue is_global_natted;
};
 
 
struct Neighbour
{
  struct GNUNET_PeerIdentity pid;
 
  struct DistanceVectorHop *dv_head;
 
  struct DistanceVectorHop *dv_tail;
 
  struct GNUNET_TIME_Absolute last_inbound;
 
  struct Queue *queue_head;
 
  struct Queue *queue_tail;
 
  struct GNUNET_PEERSTORE_IterateContext *get;
 
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  struct VirtualLink *vl;
 
  struct GNUNET_TIME_Absolute last_dv_learn_monotime;
 
  int dv_monotime_available;
 
  struct GNUNET_CONTAINER_MultiPeerMap *natted_addresses;
 
  unsigned int number_of_addresses;
 
  size_t size_of_global_addresses;
 
  enum GNUNET_GenericReturnValue is_global_natted;
};
 
 
struct IncomingRequest
{
  struct IncomingRequest *next;
 
  struct IncomingRequest *prev;
 
  struct GNUNET_PEERSTORE_Monitor *nc;
 
  struct GNUNET_PeerIdentity pid;
};
 
 
struct PeerRequest
{
  struct GNUNET_PeerIdentity pid;
 
  struct TransportClient *tc;
 
  struct GNUNET_PEERSTORE_Monitor *nc;
 
  struct GNUNET_SCHEDULER_Task *retry_task;
 
  struct GNUNET_TIME_Relative retry_backoff;
 
  enum GNUNET_MQ_PriorityPreferences pk;
 
  struct GNUNET_BANDWIDTH_Value32NBO bw;
};
 
 
enum PendingMessageType
{
  PMT_CORE = 0,
 
  PMT_FRAGMENT_BOX = 1,
 
  PMT_RELIABILITY_BOX = 2,
 
  PMT_DV_BOX = 3
};
 
 
struct PendingMessage
{
  struct PendingMessage *next_vl;
 
  struct PendingMessage *prev_vl;
 
  struct PendingMessage *next_client;
 
  struct PendingMessage *prev_client;
 
  struct PendingMessage *next_frag;
 
  struct PendingMessage *prev_frag;
 
  struct PendingAcknowledgement *pa_head;
 
  struct PendingAcknowledgement *pa_tail;
 
  struct PendingMessage *bpm;
 
  struct VirtualLink *vl;
 
  struct GNUNET_PeerIdentity target;
 
  struct QueueEntry *qe;
 
  struct TransportClient *client;
 
  struct PendingMessage *head_frag;
 
  struct PendingMessage *tail_frag;
 
  struct PendingMessage *frag_parent;
 
  struct GNUNET_TIME_Absolute timeout;
 
  struct GNUNET_TIME_Absolute next_attempt;
 
  struct MessageUUIDP msg_uuid;
 
  uint64_t logging_uuid;
 
  enum PendingMessageType pmt;
 
  enum GNUNET_MQ_PriorityPreferences prefs;
 
  struct DistanceVectorHop *used_dvh;
 
  uint16_t bytes_msg;
 
  uint16_t frag_off;
 
  uint32_t frags_in_flight;
 
  uint32_t frags_in_flight_round;
 
  uint16_t frag_count;
 
  int16_t msg_uuid_set;
 
  int16_t client_credited;
 
  /* Followed by @e bytes_msg to transmit */
};
 
 
struct TransportCummulativeAckPayload
{
  struct GNUNET_TIME_Absolute receive_time;
 
  struct AcknowledgementUUIDP ack_uuid;
};
 
 
struct AcknowledgementCummulator
{
  struct GNUNET_PeerIdentity target;
 
  struct TransportCummulativeAckPayload ack_uuids[MAX_CUMMULATIVE_ACKS];
 
  struct GNUNET_SCHEDULER_Task *task;
 
  struct GNUNET_TIME_Absolute min_transmission_time;
 
  uint32_t ack_counter;
 
  unsigned int num_acks;
};
 
 
struct PilsAddressSignContext;
 
 
struct AddressListEntry
{
  struct AddressListEntry *next;
 
  struct AddressListEntry *prev;
 
  struct TransportClient *tc;
 
  struct GNUNET_PEERSTORE_StoreHelloContext *shc;
 
  struct PilsAddressSignContext *pc;
 
  const char *address;
 
  void *signed_address;
 
  size_t signed_address_len;
 
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  struct GNUNET_SCHEDULER_Task *st;
 
  struct GNUNET_TIME_Relative expiration;
 
  struct GNUNET_TIME_Relative pils_backoff;
 
  uint32_t aid;
 
  enum GNUNET_NetworkType nt;
};
 
 
struct TransportClient
{
  struct TransportClient *next;
 
  struct TransportClient *prev;
 
  struct GNUNET_SERVICE_Client *client;
 
  struct GNUNET_MQ_Handle *mq;
 
  enum ClientType type;
 
  union
  {
    struct
    {
      struct PendingMessage *pending_msg_head;
 
      struct PendingMessage *pending_msg_tail;
    } core;
 
    struct
    {
      struct GNUNET_PeerIdentity peer;
 
      int one_shot;
    } monitor;
 
 
    struct
    {
      char *address_prefix;
 
      struct Queue *queue_head;
 
      struct Queue *queue_tail;
 
      struct AddressListEntry *addr_head;
 
      struct AddressListEntry *addr_tail;
 
      unsigned int total_queue_length;
 
      struct GNUNET_SCHEDULER_Task *free_queue_entry_task;
 
      enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc;
 
      enum GNUNET_GenericReturnValue can_burst;
 
    } communicator;
 
    struct
    {
      struct GNUNET_CONTAINER_MultiPeerMap *requests;
    } application;
  } details;
};
 
 
struct ValidationState
{
  struct GNUNET_PeerIdentity pid;
 
  struct GNUNET_TIME_Absolute valid_until;
 
  struct GNUNET_TIME_Absolute validated_until;
 
  struct GNUNET_TIME_Absolute first_challenge_use;
 
  struct GNUNET_TIME_Absolute last_challenge_use;
 
  struct GNUNET_TIME_Absolute next_challenge;
 
  struct GNUNET_TIME_Relative challenge_backoff;
 
  struct GNUNET_TIME_Relative validation_rtt;
 
  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
 
  struct GNUNET_HashCode hc;
 
  struct GNUNET_SCHEDULER_Task *revalidation_task;
 
  char *address;
 
  struct GNUNET_CONTAINER_HeapNode *hn;
 
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  uint32_t last_window_consum_limit;
 
  int awaiting_queue;
};
 
 
struct Backtalker
{
  struct GNUNET_PeerIdentity pid;
 
  struct GNUNET_TIME_Absolute monotonic_time;
 
  struct GNUNET_TIME_Absolute timeout;
 
  struct GNUNET_CRYPTO_HpkeEncapsulation last_ephemeral;
 
  struct GNUNET_SCHEDULER_Task *task;
 
  struct CommunicatorMessageContext *cmc;
 
  struct GNUNET_PEERSTORE_IterateContext *get;
 
  struct GNUNET_PEERSTORE_StoreContext *sc;
 
  size_t body_size;
};
 
static struct RingBufferEntry *ring_buffer[RING_BUFFER_SIZE];
 
static unsigned int ring_buffer_head;
 
static unsigned int is_ring_buffer_full;
 
static struct PendingMessage *ring_buffer_dv[RING_BUFFER_SIZE];
 
static unsigned int ring_buffer_dv_head;
 
static unsigned int is_ring_buffer_dv_full;
 
static struct TransportClient *clients_head;
 
static struct TransportClient *clients_tail;
 
static struct GNUNET_STATISTICS_Handle *GST_stats;
 
static const struct GNUNET_CONFIGURATION_Handle *GST_cfg;
 
static struct GNUNET_SERVICE_Handle *GST_service;
 
static struct GNUNET_SCHEDULER_Task *client_grace_task;
 
struct GNUNET_HELLO_Builder *GST_my_hello;
 
static struct GNUNET_CONTAINER_MultiPeerMap *neighbours;
 
static struct GNUNET_CONTAINER_MultiPeerMap *backtalkers;
 
static struct GNUNET_CONTAINER_MultiPeerMap *ack_cummulators;
 
static struct GNUNET_CONTAINER_MultiUuidmap *pending_acks;
 
static struct GNUNET_CONTAINER_MultiPeerMap *dv_routes;
 
static struct GNUNET_CONTAINER_MultiPeerMap *validation_map;
 
static struct GNUNET_CONTAINER_MultiHashMap *revalidation_map;
 
static struct GNUNET_CONTAINER_MultiPeerMap *links;
 
static struct GNUNET_CONTAINER_MultiShortmap *dvlearn_map;
 
static struct LearnLaunchEntry *lle_head = NULL;
 
static struct LearnLaunchEntry *lle_tail = NULL;
 
static struct GNUNET_CONTAINER_Heap *validation_heap;
 
struct GNUNET_NAT_Handle *nh;
 
static struct GNUNET_PEERSTORE_Handle *peerstore;
 
static struct GNUNET_PILS_Handle *pils;
 
struct PilsRequest
{
  struct PilsRequest *prev;
 
  struct PilsRequest *next;
 
  struct GNUNET_PILS_Operation *op;
};
 
static struct PilsRequest *pils_requests_head;
 
static struct PilsRequest *pils_requests_tail;
 
static enum GNUNET_GenericReturnValue
sign_by_my_identity (const struct GNUNET_CRYPTO_SignaturePurpose *purpose,
                     struct GNUNET_CRYPTO_EddsaSignature *sig)
{
  const struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 
  my_private_key = GNUNET_PILS_get_private_key (pils);
  if (NULL == my_private_key)
  {
    /* #run() enables local key access, so this means the key on disk does
       not match the identity PILS announced, or no identity is known yet. */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "No private key for our peer identity, cannot sign\n");
    GNUNET_STATISTICS_update (GST_stats,
                              "# signatures failed (no private key)",
                              1,
                              GNUNET_NO);
    return GNUNET_SYSERR;
  }
  return GNUNET_CRYPTO_eddsa_sign_ (my_private_key, purpose, sig);
}
 
 
static struct GNUNET_SCHEDULER_Task *dvlearn_task;
 
static struct GNUNET_TIME_Relative dvlearn_pils_backoff;
 
static struct GNUNET_SCHEDULER_Task *validation_task;
 
static struct GNUNET_SCHEDULER_Task *pils_feed_task;
 
static struct IncomingRequest *ir_head;
 
static struct IncomingRequest *ir_tail;
 
static unsigned int ir_total;
 
static unsigned long long logging_uuid_gen;
 
static enum GNUNET_GenericReturnValue burst_running;
 
static struct GNUNET_TIME_Absolute hello_mono_time;
 
static int in_shutdown;
 
static struct GNUNET_SCHEDULER_Task *burst_task;
 
static struct GNUNET_StartBurstCls *burst_task_cls;
 
struct GNUNET_SCHEDULER_Task *burst_timeout_task;
 
enum GNUNET_GenericReturnValue use_burst;
 
static unsigned int
get_age ()
{
  struct GNUNET_TIME_Absolute now;
 
  now = GNUNET_TIME_absolute_get ();
  return now.abs_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us / 15;
}
 
 
static void
free_incoming_request (struct IncomingRequest *ir)
{
  GNUNET_CONTAINER_DLL_remove (ir_head, ir_tail, ir);
  GNUNET_assert (ir_total > 0);
  ir_total--;
  if (NULL != ir->nc)
    GNUNET_PEERSTORE_monitor_stop (ir->nc);
  ir->nc = NULL;
  GNUNET_free (ir);
}
 
 
static void
free_pending_acknowledgement (struct PendingAcknowledgement *pa)
{
  struct Queue *q = pa->queue;
  struct PendingMessage *pm = pa->pm;
  struct DistanceVectorHop *dvh = pa->dvh;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "free_pending_acknowledgement\n");
  if (NULL != q)
  {
    GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa);
    pa->queue = NULL;
  }
  if (NULL != pm)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message\n");
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message %" PRIu64 "\n",
                pm->logging_uuid);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message %u\n",
                pm->pmt);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message %s\n",
                GNUNET_uuid2s (&pa->ack_uuid.value));
    GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
    pa->pm = NULL;
  }
  if (NULL != dvh)
  {
    GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
    pa->dvh = NULL;
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multiuuidmap_remove (pending_acks,
                                                       &pa->ack_uuid.value,
                                                       pa));
  GNUNET_free (pa);
}
 
 
static void
free_fragment_tree (struct PendingMessage *root)
{
  struct PendingMessage *frag;
 
  while (NULL != (frag = root->head_frag))
  {
    struct PendingAcknowledgement *pa;
 
    free_fragment_tree (frag);
    /* Release them: a `struct PendingAcknowledgement' whose @e pm is gone
       can never do anything useful again -- handle_acknowledged() would
       just free it -- but it stays in #pending_acks, and only an ACK that
       may never come takes it out.  Merely detaching it here leaked one
       entry per fragment that was not acknowledged before its message went
       away, which on a lossy link is unbounded growth. */
    while (NULL != (pa = frag->pa_head))
      free_pending_acknowledgement (pa);
    GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag, frag);
    if (NULL != frag->qe)
    {
      GNUNET_assert (frag == frag->qe->pm);
      frag->qe->pm = NULL;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Free frag %p\n",
                frag);
    GNUNET_free (frag);
  }
}
 
 
static void
free_pending_message (struct PendingMessage *pm)
{
  struct TransportClient *tc = pm->client;
  struct VirtualLink *vl = pm->vl;
  struct PendingAcknowledgement *pa;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Freeing pm %p\n",
              pm);
  if (NULL != tc)
  {
    GNUNET_CONTAINER_MDLL_remove (client,
                                  tc->details.core.pending_msg_head,
                                  tc->details.core.pending_msg_tail,
                                  pm);
  }
  if ((NULL != vl) && (NULL == pm->frag_parent))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Removing pm %" PRIu64 "\n",
                pm->logging_uuid);
    GNUNET_CONTAINER_MDLL_remove (vl,
                                  vl->pending_msg_head,
                                  vl->pending_msg_tail,
                                  pm);
  }
  else if (NULL != pm->frag_parent && PMT_DV_BOX != pm->pmt)
  {
    struct PendingMessage *root = pm->frag_parent;
 
    while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
      root = root->frag_parent;
 
    root->frag_count--;
  }
  /* Same as in #free_fragment_tree(): the message these acknowledgements
     belong to is going away, so they are garbage rather than orphans. */
  while (NULL != (pa = pm->pa_head))
    free_pending_acknowledgement (pa);
 
  free_fragment_tree (pm);
  if (NULL != pm->qe)
  {
    GNUNET_assert (pm == pm->qe->pm);
    pm->qe->pm = NULL;
  }
  if (NULL != pm->bpm)
  {
    free_fragment_tree (pm->bpm);
    /* @e bpm is released with GNUNET_free() rather than through
       #free_pending_message(), so nothing here ever unlinked the
       acknowledgements attached to the box itself -- only those of its
       fragments, via the call above.  They kept @e pm pointing into the
       block we are about to release, and #handle_acknowledged() follows
       that pointer when the ACK finally arrives. */
    while (NULL != (pa = pm->bpm->pa_head))
      free_pending_acknowledgement (pa);
    if (NULL != pm->bpm->qe)
    {
      struct QueueEntry *qe = pm->bpm->qe;
 
      qe->pm = NULL;
    }
    GNUNET_free (pm->bpm);
  }
 
  GNUNET_free (pm);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Freeing pm done\n");
}
 
 
static void
free_reassembly_context (struct ReassemblyContext *rc)
{
  struct VirtualLink *vl = rc->virtual_link;
 
  GNUNET_assert (rc == GNUNET_CONTAINER_heap_remove_node (rc->hn));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap32_remove (vl->reassembly_map,
                                                         rc->msg_uuid.uuid,
                                                         rc));
  GNUNET_free (rc);
}
 
 
static void
reassembly_cleanup_task (void *cls)
{
  struct VirtualLink *vl = cls;
  struct ReassemblyContext *rc;
 
  vl->reassembly_timeout_task = NULL;
  while (NULL != (rc = GNUNET_CONTAINER_heap_peek (vl->reassembly_heap)))
  {
    if (0 == GNUNET_TIME_absolute_get_remaining (rc->reassembly_timeout)
        .rel_value_us)
    {
      free_reassembly_context (rc);
      continue;
    }
    GNUNET_assert (NULL == vl->reassembly_timeout_task);
    vl->reassembly_timeout_task =
      GNUNET_SCHEDULER_add_at (rc->reassembly_timeout,
                               &reassembly_cleanup_task,
                               vl);
    return;
  }
}
 
 
static int
free_reassembly_cb (void *cls, uint32_t key, void *value)
{
  struct ReassemblyContext *rc = value;
 
  (void) cls;
  (void) key;
  free_reassembly_context (rc);
  return GNUNET_OK;
}
 
 
static void
finish_cmc_handling_with_continue (struct CommunicatorMessageContext *cmc,
                                   unsigned int free_cmc);
 
 
static void
release_stalled_cmc (struct VirtualLink *vl,
                     struct CommunicatorMessageContext *cmc);
 
 
static void
free_burst_cls (struct GNUNET_StartBurstCls *sb_cls);
 
 
static void
send_ok_to_client (struct TransportClient *tc,
                   const struct GNUNET_PeerIdentity *pid)
{
  struct GNUNET_MQ_Envelope *env;
  struct SendOkMessage *so_msg;
 
  if (NULL == tc)
    return;
  env = GNUNET_MQ_msg (so_msg, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
  so_msg->peer = *pid;
  GNUNET_MQ_send (tc->mq, env);
}
 
 
static void
credit_client (struct PendingMessage *pm)
{
  if ((NULL == pm->client) || (GNUNET_YES == pm->client_credited))
    return;
  pm->client_credited = GNUNET_YES;
  send_ok_to_client (pm->client, &pm->vl->target);
}
 
 
static void
free_virtual_link (struct VirtualLink *vl)
{
  struct PendingMessage *pm;
  struct CoreSentContext *csc;
  struct CommunicatorMessageContext *cmc;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "free virtual link %p\n",
              vl);
 
  /* Communicators that are blocked on CORE flow control for this link MUST
     be resumed here.  Otherwise their `struct CommunicatorMessageContext's
     leak and -- worse -- those clients never get their
     GNUNET_SERVICE_client_continue() and stall forever. */
  while (NULL != (cmc = vl->cmc_head))
    release_stalled_cmc (vl, cmc);
  if (NULL != vl->core_fc_stall_task)
  {
    GNUNET_SCHEDULER_cancel (vl->core_fc_stall_task);
    vl->core_fc_stall_task = NULL;
  }
 
  if (NULL != vl->reassembly_map)
  {
    GNUNET_CONTAINER_multihashmap32_iterate (vl->reassembly_map,
                                             &free_reassembly_cb,
                                             NULL);
    GNUNET_CONTAINER_multihashmap32_destroy (vl->reassembly_map);
    vl->reassembly_map = NULL;
    GNUNET_CONTAINER_heap_destroy (vl->reassembly_heap);
    vl->reassembly_heap = NULL;
  }
  if (NULL != vl->reassembly_timeout_task)
  {
    GNUNET_SCHEDULER_cancel (vl->reassembly_timeout_task);
    vl->reassembly_timeout_task = NULL;
  }
  while (NULL != (pm = vl->pending_msg_head))
  {
    /* These never got transmitted, so #completed_pending_message() will not
       run for them and nobody else answers their SEND either.  Return the
       window credit anyway: CORE keeps its `struct Neighbour' -- and thus
       the window -- until it sees our DISCONNECT, and #handle_client_send()
       deliberately tolerates a SEND for a link that is already gone, so a
       client can easily still be sending while we free this. */
    credit_client (pm);
    free_pending_message (pm);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (links, &vl->target, vl));
  if (NULL != vl->visibility_task)
  {
    GNUNET_SCHEDULER_cancel (vl->visibility_task);
    vl->visibility_task = NULL;
  }
  if (NULL != vl->fc_retransmit_task)
  {
    GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
    vl->fc_retransmit_task = NULL;
  }
  while (NULL != (csc = vl->csc_head))
  {
    GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, csc);
    GNUNET_assert (vl == csc->vl);
    csc->vl = NULL;
  }
  if (NULL != vl->unconfirmed_timeout_task)
  {
    GNUNET_SCHEDULER_cancel (vl->unconfirmed_timeout_task);
    vl->unconfirmed_timeout_task = NULL;
  }
  if (NULL != vl->ic)
  {
    /* the closure of this iteration is @e sb_cls, released just below */
    GNUNET_PEERSTORE_iteration_stop (vl->ic);
    vl->ic = NULL;
  }
  if (NULL != vl->sb_cls)
  {
    /* Cancels #burst_task if that task's closure is ours: it would
       otherwise run on this (freed) link. */
    free_burst_cls (vl->sb_cls);
    GNUNET_assert (NULL == vl->sb_cls);
  }
  GNUNET_free (vl->burst_addr);
  GNUNET_break (NULL == vl->n);
  GNUNET_break (NULL == vl->dv);
  GNUNET_free (vl);
}
 
 
static void
free_validation_state (struct ValidationState *vs)
{
  if (NULL != vs->revalidation_task)
  {
    GNUNET_SCHEDULER_cancel (vs->revalidation_task);
    vs->revalidation_task = NULL;
  }
  /*memcpy (&hkey,
          &hc,
          sizeof (hkey));*/
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Remove key %s for address %s map size %u contains %u during freeing state\n",
              GNUNET_h2s (&vs->hc),
              vs->address,
              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
                                                      &vs->hc));
  GNUNET_CONTAINER_multihashmap_remove (revalidation_map, &vs->hc, vs);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (validation_map, &vs->pid, vs));
  GNUNET_CONTAINER_heap_remove_node (vs->hn);
  vs->hn = NULL;
  if (NULL != vs->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (vs->sc);
    vs->sc = NULL;
  }
  GNUNET_free (vs->address);
  GNUNET_free (vs);
}
 
 
static struct Neighbour *
lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
{
  return GNUNET_CONTAINER_multipeermap_get (neighbours, pid);
}
 
 
static struct VirtualLink *
lookup_virtual_link (const struct GNUNET_PeerIdentity *pid)
{
  return GNUNET_CONTAINER_multipeermap_get (links, pid);
}
 
 
struct MonitorEvent
{
  struct GNUNET_TIME_Absolute last_validation;
  struct GNUNET_TIME_Absolute valid_until;
  struct GNUNET_TIME_Absolute next_validation;
 
  struct GNUNET_TIME_Relative rtt;
 
  enum GNUNET_TRANSPORT_ConnectionStatus cs;
 
  uint32_t num_msg_pending;
 
  uint32_t num_bytes_pending;
};
 
 
static void
free_distance_vector_hop (struct DistanceVectorHop *dvh)
{
  struct Neighbour *n = dvh->next_hop;
  struct DistanceVector *dv = dvh->dv;
  struct PendingAcknowledgement *pa;
 
  while (NULL != (pa = dvh->pa_head))
  {
    GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
    pa->dvh = NULL;
  }
  GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh);
  GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, dvh);
  GNUNET_free (dvh);
}
 
 
static void
check_link_down (void *cls);
 
 
static void
cores_send_disconnect_info (const struct GNUNET_PeerIdentity *pid)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Informing CORE clients about disconnect from %s\n",
              GNUNET_i2s (pid));
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    struct GNUNET_MQ_Envelope *env;
    struct DisconnectInfoMessage *dim;
 
    if (CT_CORE != tc->type)
      continue;
    env = GNUNET_MQ_msg (dim, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
    dim->peer = *pid;
    GNUNET_MQ_send (tc->mq, env);
  }
}
 
 
static void
try_to_bring_link_up (const struct GNUNET_PeerIdentity *pid);
 
 
static void
disconnect_and_free_virtual_link (struct VirtualLink *vl)
{
  struct GNUNET_PeerIdentity target = vl->target;
 
  for (struct PendingMessage *pm = vl->pending_msg_head;
       NULL != pm;
       pm = pm->next_vl)
    credit_client (pm);
  cores_send_disconnect_info (&vl->target);
  free_virtual_link (vl);
  /* Start getting it back now.  Only #handle_validation_response() can
     rebuild it, and a successful validation parks @e revalidation_task just
     short of #ADDRESS_VALIDATION_LIFETIME -- four hours away. */
  try_to_bring_link_up (&target);
}
 
 
static void
free_dv_route (struct DistanceVector *dv)
{
  struct DistanceVectorHop *dvh;
  struct VirtualLink *vl;
 
  while (NULL != (dvh = dv->dv_head))
    free_distance_vector_hop (dvh);
 
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (dv_routes, &dv->target, dv));
  if (NULL != (vl = dv->vl))
  {
    GNUNET_assert (dv == vl->dv);
    vl->dv = NULL;
    if (NULL == vl->n)
    {
      disconnect_and_free_virtual_link (vl);
    }
    else
    {
      /* @e visibility_task is NULL while #check_link_down() itself runs, and
         #GNUNET_SCHEDULER_cancel() dereferences its argument. */
      if (NULL != vl->visibility_task)
        GNUNET_SCHEDULER_cancel (vl->visibility_task);
      vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl);
    }
    dv->vl = NULL;
  }
 
  if (NULL != dv->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (dv->timeout_task);
    dv->timeout_task = NULL;
  }
  GNUNET_free (dv->km);
  GNUNET_free (dv);
}
 
 
static void
notify_monitor (struct TransportClient *tc,
                const struct GNUNET_PeerIdentity *peer,
                const char *address,
                enum GNUNET_NetworkType nt,
                const struct MonitorEvent *me)
{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_MonitorData *md;
  size_t addr_len = strlen (address) + 1;
 
  env = GNUNET_MQ_msg_extra (md,
                             addr_len,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA);
  md->nt = htonl ((uint32_t) nt);
  md->peer = *peer;
  md->last_validation = GNUNET_TIME_absolute_hton (me->last_validation);
  md->valid_until = GNUNET_TIME_absolute_hton (me->valid_until);
  md->next_validation = GNUNET_TIME_absolute_hton (me->next_validation);
  md->rtt = GNUNET_TIME_relative_hton (me->rtt);
  md->cs = htonl ((uint32_t) me->cs);
  md->num_msg_pending = htonl (me->num_msg_pending);
  md->num_bytes_pending = htonl (me->num_bytes_pending);
  memcpy (&md[1], address, addr_len);
  GNUNET_MQ_send (tc->mq, env);
}
 
 
static void
notify_monitors (const struct GNUNET_PeerIdentity *peer,
                 const char *address,
                 enum GNUNET_NetworkType nt,
                 const struct MonitorEvent *me)
{
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_MONITOR != tc->type)
      continue;
    if (tc->details.monitor.one_shot)
      continue;
    if ((GNUNET_NO == GNUNET_is_zero (&tc->details.monitor.peer)) &&
        (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer)))
      continue;
    notify_monitor (tc, peer, address, nt, me);
  }
}
 
 
static void *
client_connect_cb (void *cls,
                   struct GNUNET_SERVICE_Client *client,
                   struct GNUNET_MQ_Handle *mq)
{
  struct TransportClient *tc;
 
  (void) cls;
  tc = GNUNET_new (struct TransportClient);
  tc->client = client;
  tc->mq = mq;
  GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p of type %u connected\n",
              tc,
              tc->type);
  return tc;
}
 
 
static enum GNUNET_GenericReturnValue
remove_global_addresses (void *cls,
                         const struct GNUNET_PeerIdentity *pid,
                         void *value)
{
  struct TransportGlobalNattedAddress *tgna = value;
  (void) cls;
 
  GNUNET_free (tgna);
 
  return GNUNET_OK;
}
 
 
static void
free_neighbour (struct Neighbour *neighbour,
                enum GNUNET_GenericReturnValue drop_link)
{
  struct DistanceVectorHop *dvh;
  struct VirtualLink *vl;
 
  GNUNET_assert (NULL == neighbour->queue_head);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (neighbours,
                                                       &neighbour->pid,
                                                       neighbour));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Freeing neighbour\n");
  GNUNET_CONTAINER_multipeermap_iterate (neighbour->natted_addresses,
                                         &remove_global_addresses,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (neighbour->natted_addresses);
  while (NULL != (dvh = neighbour->dv_head))
  {
    struct DistanceVector *dv = dvh->dv;
 
    free_distance_vector_hop (dvh);
    if (NULL == dv->dv_head)
      free_dv_route (dv);
  }
  if (NULL != neighbour->get)
  {
    GNUNET_PEERSTORE_iteration_stop (neighbour->get);
    neighbour->get = NULL;
  }
  if (NULL != neighbour->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (neighbour->sc);
    neighbour->sc = NULL;
  }
  if (NULL != (vl = neighbour->vl))
  {
    GNUNET_assert (neighbour == vl->n);
    vl->n = NULL;
    if ((GNUNET_YES == drop_link) || (NULL == vl->dv))
    {
      disconnect_and_free_virtual_link (vl);
    }
    else
    {
      /* See #free_dv_route(): may be NULL under #check_link_down(). */
      if (NULL != vl->visibility_task)
        GNUNET_SCHEDULER_cancel (vl->visibility_task);
      vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl);
    }
    neighbour->vl = NULL;
  }
  GNUNET_free (neighbour);
}
 
 
static void
core_send_connect_info (struct TransportClient *tc,
                        const struct GNUNET_PeerIdentity *pid)
{
  struct GNUNET_MQ_Envelope *env;
  struct ConnectInfoMessage *cim;
 
  GNUNET_assert (CT_CORE == tc->type);
  env = GNUNET_MQ_msg (cim, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
  cim->id = *pid;
  GNUNET_MQ_send (tc->mq, env);
}
 
 
static void
cores_send_connect_info (const struct GNUNET_PeerIdentity *pid)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Informing CORE clients about connection to %s\n",
              GNUNET_i2s (pid));
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_CORE != tc->type)
      continue;
    core_send_connect_info (tc, pid);
  }
}
 
 
static void
transmit_on_queue (void *cls);
 
 
static unsigned int
check_for_queue_with_higher_prio (struct Queue *queue, struct Queue *queue_head)
{
  for (struct Queue *s = queue_head; NULL != s;
       s = s->next_neighbour)
  {
    if (s == queue)
      continue;
    if (s->tc->details.communicator.address_prefix !=
        queue->tc->details.communicator.address_prefix)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "queue address %s qid %u compare with queue: address %s qid %u\n",
                  queue->address,
                  queue->qid,
                  s->address,
                  s->qid);
      if ((s->priority > queue->priority) && (0 < s->q_capacity) &&
          (QUEUE_LENGTH_LIMIT > s->queue_length) )
        return GNUNET_YES;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Lower prio\n");
    }
  }
  return GNUNET_NO;
}
 
 
static void
arm_free_queue_entry_task (struct TransportClient *tc);
 
 
static void
schedule_transmit_on_queue (struct GNUNET_TIME_Relative delay,
                            struct Queue *queue,
                            enum GNUNET_SCHEDULER_Priority p)
{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
  if (queue->validated_until.abs_value_us < now.abs_value_us)
    return;
  if (check_for_queue_with_higher_prio (queue,
                                        queue->neighbour->queue_head))
    return;
 
  if (queue->tc->details.communicator.total_queue_length >=
      COMMUNICATOR_TOTAL_QUEUE_LIMIT)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission on queue %s (QID %u) throttled due to communicator queue limit\n",
                queue->address,
                queue->qid);
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Transmission throttled due to communicator queue limit",
      1,
      GNUNET_NO);
    queue->idle = GNUNET_NO;
    /* @e total_queue_length is shared by every peer this communicator serves,
       so at the limit we can send to none of them, and the only things that
       lower it again are an ACK from the communicator, #free_queue() and
       #free_timedout_queue_entry().  If we got here because a peer stopped
       acknowledging, no ACK is coming; and we just declined to arm
       @e transmit_task, so #queue_send_msg() -- the *only* place that arms
       the sweeper -- will not run either.  That leaves nothing at all to
       recover the count, and the communicator stays mute towards every peer
       until some unrelated queue happens to go down.  Keep the sweeper
       going. */
    arm_free_queue_entry_task (queue->tc);
    return;
  }
  if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission on queue %s (QID %u) throttled due to communicator queue length limit\n",
                queue->address,
                queue->qid);
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to queue queue limit",
                              1,
                              GNUNET_NO);
    queue->idle = GNUNET_NO;
    /* Same reasoning as above, for the per-queue limit. */
    arm_free_queue_entry_task (queue->tc);
    return;
  }
  if (0 == queue->q_capacity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission on queue %s (QID %u) throttled due to communicator message  has capacity %"
                PRIu64 ".\n",
                queue->address,
                queue->qid,
                queue->q_capacity);
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to message queue capacity",
                              1,
                              GNUNET_NO);
    queue->idle = GNUNET_NO;
    return;
  }
  /* queue might indeed be ready, schedule it */
  if (NULL != queue->transmit_task)
    GNUNET_SCHEDULER_cancel (queue->transmit_task);
  queue->transmit_task =
    GNUNET_SCHEDULER_add_delayed_with_priority (delay, p, &transmit_on_queue,
                                                queue);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Considering transmission on queue `%s' QID %llu to %s\n",
              queue->address,
              (unsigned long long) queue->qid,
              GNUNET_i2s (&queue->neighbour->pid));
}
 
 
static void
start_address_validation (const struct GNUNET_PeerIdentity *pid,
                          const char *address);
 
 
static void
check_link_down (void *cls)
{
  struct VirtualLink *vl = cls;
  struct DistanceVector *dv = vl->dv;
  struct Neighbour *n = vl->n;
  struct GNUNET_TIME_Absolute dvh_timeout;
  struct GNUNET_TIME_Absolute q_timeout;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Checking if link is down\n");
  vl->visibility_task = NULL;
  dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  if (NULL != dv)
  {
    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
         pos = pos->next_dv)
      dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout,
                                              pos->path_valid_until);
    if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
    {
      vl->dv->vl = NULL;
      vl->dv = NULL;
    }
  }
  q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  /* NOTE: @e n may be NULL here: #free_neighbour() clears vl->n and then
     schedules us when the link still has a DV route. */
  if (NULL != n)
  {
    struct GNUNET_TIME_Absolute liveness_deadline;
 
    /* A successful validation is good for #ADDRESS_VALIDATION_LIFETIME (four
       hours).  Do not take a communicator's word for that long: cap what the
       queues are worth by how recently this neighbour actually said anything
       to us.  Otherwise a communicator that stops working without sending a
       QUEUE_TEARDOWN keeps this link -- and CORE's idea of the connection --
       alive until the validation expires. */
    liveness_deadline = GNUNET_TIME_absolute_add (n->last_inbound,
                                                  NEIGHBOUR_LIVENESS_TIMEOUT);
    for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
      q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
    if (GNUNET_TIME_absolute_cmp (liveness_deadline, <, q_timeout))
    {
      if (0 ==
          GNUNET_TIME_absolute_get_remaining (liveness_deadline).rel_value_us)
      {
        /* Only reachable if a communicator failed to tear its queue down. */
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Neighbour %s was silent for %s while its communicator "
                    "kept claiming the queue works; treating link as down\n",
                    GNUNET_i2s (&vl->target),
                    GNUNET_STRINGS_relative_time_to_string (
                      NEIGHBOUR_LIVENESS_TIMEOUT,
                      GNUNET_YES));
        GNUNET_STATISTICS_update (GST_stats,
                                  "# links dropped (neighbour silent)",
                                  1,
                                  GNUNET_NO);
      }
      q_timeout = liveness_deadline;
    }
    if (0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
    {
      vl->n->vl = NULL;
      vl->n = NULL;
    }
  }
  if ((NULL == vl->n) && (NULL == vl->dv))
  {
    disconnect_and_free_virtual_link (vl);
    /* @e n (if any) outlives the link, and so do its queues: the liveness cap
       above drops a link whose addresses are still well inside
       #ADDRESS_VALIDATION_LIFETIME.  In that state nothing would ever ask for
       a fresh challenge -- @e revalidation_task does not fire until the four
       hour validity is nearly over, and the HELLO path reaches
       #start_address_validation() only to find an address that still counts
       as valid.  Since #handle_validation_response() is the only thing that
       can rebuild this link and tell CORE about the peer again, ask for that
       validation now, or CORE never hears about this peer again. */
    if (NULL != n)
      for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
        start_address_validation (&n->pid, q->address);
    return;
  }
  vl->visibility_task =
    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_max (q_timeout, dvh_timeout),
                             &check_link_down,
                             vl);
}
 
 
static void
free_queue (struct Queue *queue)
{
  struct Neighbour *neighbour = queue->neighbour;
  struct TransportClient *tc = queue->tc;
  struct MonitorEvent me = { .cs = GNUNET_TRANSPORT_CS_DOWN,
                             .rtt = GNUNET_TIME_UNIT_FOREVER_REL };
  struct QueueEntry *qe;
  int maxxed;
  struct PendingAcknowledgement *pa;
  struct VirtualLink *vl;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Cleaning up queue %u\n", queue->qid);
  if (NULL != queue->mo)
  {
    GNUNET_PEERSTORE_monitor_stop (queue->mo);
    queue->mo = NULL;
  }
  if (NULL != queue->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (queue->transmit_task);
    queue->transmit_task = NULL;
  }
  while (NULL != (pa = queue->pa_head))
  {
    GNUNET_CONTAINER_MDLL_remove (queue, queue->pa_head, queue->pa_tail, pa);
    pa->queue = NULL;
  }
 
  GNUNET_CONTAINER_MDLL_remove (neighbour,
                                neighbour->queue_head,
                                neighbour->queue_tail,
                                queue);
  GNUNET_CONTAINER_MDLL_remove (client,
                                tc->details.communicator.queue_head,
                                tc->details.communicator.queue_tail,
                                queue);
  maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT <=
            tc->details.communicator.total_queue_length);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Cleaning up queue with length %u\n",
              queue->queue_length);
  while (NULL != (qe = queue->queue_head))
  {
    GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe);
    queue->queue_length--;
    tc->details.communicator.total_queue_length--;
    if (NULL != qe->pm)
    {
      GNUNET_assert (qe == qe->pm->qe);
      qe->pm->qe = NULL;
    }
    GNUNET_free (qe);
  }
  GNUNET_assert (0 == queue->queue_length);
  if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT >
                   tc->details.communicator.total_queue_length))
  {
    /* Communicator dropped below threshold, resume all _other_ queues */
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Transmission throttled due to communicator queue limit",
      -1,
      GNUNET_NO);
    for (struct Queue *s = tc->details.communicator.queue_head; NULL != s;
         s = s->next_client)
      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                  s,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  }
  notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
  GNUNET_free (queue);
 
  vl = lookup_virtual_link (&neighbour->pid);
  if ((NULL != vl) && (neighbour == vl->n))
  {
    /* See #free_dv_route(): may be NULL under #check_link_down(), which is
       also what clears it -- so the call below needs no re-arm here. */
    if (NULL != vl->visibility_task)
      GNUNET_SCHEDULER_cancel (vl->visibility_task);
    vl->visibility_task = NULL;
    check_link_down (vl);
  }
  if (NULL == neighbour->queue_head)
  {
    free_neighbour (neighbour, GNUNET_NO);
  }
}
 
 
static void
cancel_address_store (struct AddressListEntry *ale);
 
 
static void
free_address_list_entry (struct AddressListEntry *ale)
{
  struct TransportClient *tc = ale->tc;
 
  GNUNET_CONTAINER_DLL_remove (tc->details.communicator.addr_head,
                               tc->details.communicator.addr_tail,
                               ale);
  /* Cancels @e sc, @e shc and the pending PILS signature request, all of
     which would otherwise run their callbacks on this freed entry. */
  cancel_address_store (ale);
  if (NULL != ale->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (ale->sc);
    ale->sc = NULL;
  }
  if (NULL != ale->shc)
  {
    GNUNET_PEERSTORE_hello_add_cancel (ale->shc);
    ale->shc = NULL;
  }
  if (NULL != ale->st)
  {
    GNUNET_SCHEDULER_cancel (ale->st);
    ale->st = NULL;
  }
  if (NULL != ale->signed_address)
    GNUNET_free (ale->signed_address);
  GNUNET_free (ale);
}
 
 
static int
stop_peer_request (void *cls,
                   const struct GNUNET_PeerIdentity *pid,
                   void *value)
{
  struct TransportClient *tc = cls;
  struct PeerRequest *pr = value;
 
  if (NULL != pr->retry_task)
  {
    GNUNET_SCHEDULER_cancel (pr->retry_task);
    pr->retry_task = NULL;
  }
  if (NULL != pr->nc)
    GNUNET_PEERSTORE_monitor_stop (pr->nc);
  pr->nc = NULL;
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests,
                                          pid,
                                          pr));
  GNUNET_free (pr);
 
  return GNUNET_OK;
}
 
 
static void
do_shutdown (void *cls);
 
 
static enum GNUNET_GenericReturnValue
detach_cmcs_from_link (void *cls,
                       const struct GNUNET_PeerIdentity *pid,
                       void *value)
{
  const struct TransportClient *tc = cls;
  struct VirtualLink *vl = value;
 
  (void) pid;
  for (struct CommunicatorMessageContext *cmc = vl->cmc_head;
       NULL != cmc;
       cmc = cmc->next)
    if (tc == cmc->tc)
      cmc->tc = NULL;
  return GNUNET_OK;
}
 
 
static enum GNUNET_GenericReturnValue
detach_cmc_from_backtalker (void *cls,
                            const struct GNUNET_PeerIdentity *pid,
                            void *value)
{
  const struct TransportClient *tc = cls;
  struct Backtalker *b = value;
 
  (void) pid;
  if ((NULL != b->cmc) && (tc == b->cmc->tc))
    b->cmc->tc = NULL;
  return GNUNET_OK;
}
 
 
static void
detach_cmcs_from_client (const struct TransportClient *tc)
{
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &detach_cmcs_from_link,
                                         (void *) tc);
  GNUNET_CONTAINER_multipeermap_iterate (backtalkers,
                                         &detach_cmc_from_backtalker,
                                         (void *) tc);
  for (unsigned int i = 0; i < RING_BUFFER_SIZE; i++)
    if ((NULL != ring_buffer[i]) &&
        (tc == ring_buffer[i]->cmc->tc))
      ring_buffer[i]->cmc->tc = NULL;
}
 
 
static void
client_disconnect_cb (void *cls,
                      struct GNUNET_SERVICE_Client *client,
                      void *app_ctx)
{
  struct TransportClient *tc = app_ctx;
 
  (void) cls;
  (void) client;
  GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
  switch (tc->type)
  {
  case CT_NONE:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Unknown Client %p disconnected, cleaning up.\n",
                tc);
    break;
 
  case CT_CORE: {
      struct PendingMessage *pm;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "CORE Client %p disconnected, cleaning up.\n",
                  tc);
 
 
      while (NULL != (pm = tc->details.core.pending_msg_head))
      {
        GNUNET_CONTAINER_MDLL_remove (client,
                                      tc->details.core.pending_msg_head,
                                      tc->details.core.pending_msg_tail,
                                      pm);
        pm->client = NULL;
      }
    }
    break;
 
  case CT_MONITOR:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "MONITOR Client %p disconnected, cleaning up.\n",
                tc);
 
    break;
 
  case CT_COMMUNICATOR: {
      struct Queue *q;
      struct AddressListEntry *ale;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "COMMUNICATOR Client %p disconnected, cleaning up.\n",
                  tc);
 
      /* MUST come first: freeing the queues below can tear a virtual link
         down, and #free_virtual_link() releases the cmcs parked on it. */
      detach_cmcs_from_client (tc);
      if (NULL != tc->details.communicator.free_queue_entry_task)
        GNUNET_SCHEDULER_cancel (
          tc->details.communicator.free_queue_entry_task);
      while (NULL != (q = tc->details.communicator.queue_head))
        free_queue (q);
      while (NULL != (ale = tc->details.communicator.addr_head))
        free_address_list_entry (ale);
      GNUNET_free (tc->details.communicator.address_prefix);
    }
    break;
 
  case CT_APPLICATION:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "APPLICATION Client %p disconnected, cleaning up.\n",
                tc);
 
    GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests,
                                           &stop_peer_request,
                                           tc);
    GNUNET_CONTAINER_multipeermap_destroy (tc->details.application.requests);
    break;
  }
  GNUNET_free (tc);
  if ((GNUNET_YES == in_shutdown) && (NULL == clients_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Our last client disconnected\n");
    do_shutdown (cls);
  }
}
 
 
static int
notify_client_connect_info (void *cls,
                            const struct GNUNET_PeerIdentity *pid,
                            void *value)
{
  struct TransportClient *tc = cls;
  struct VirtualLink *vl = value;
 
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
    return GNUNET_OK;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Telling new CORE client about existing connection to %s\n",
              GNUNET_i2s (pid));
  core_send_connect_info (tc, pid);
  return GNUNET_OK;
}
 
 
static void
finish_cmc_handling_with_continue (struct CommunicatorMessageContext *cmc,
                                   unsigned
                                   int free_cmc);
 
static enum GNUNET_GenericReturnValue
resume_communicators (void *cls,
                      const struct GNUNET_PeerIdentity *pid,
                      void *value)
{
  struct VirtualLink *vl = value;
  struct CommunicatorMessageContext *cmc;
 
  /* resume communicators */
  while (NULL != (cmc = vl->cmc_tail))
    release_stalled_cmc (vl, cmc);
  if (NULL != vl->core_fc_stall_task)
  {
    GNUNET_SCHEDULER_cancel (vl->core_fc_stall_task);
    vl->core_fc_stall_task = NULL;
  }
  /* A CORE client that just attached has nothing outstanding, so give it a
     full window.  The RECV_OKs that would have returned the credit spent by
     its predecessor died with that client, and #handle_client_recv_ok() is
     the only thing that ever raises this counter -- so without the reset
     every message on this link takes the "CORE ran out of window" path from
     here on, and only #core_fc_stalled() (after CORE_FC_STALL_TIMEOUT, and
     once per round) ever lets any through. */
  vl->core_recv_window = RECV_WINDOW_SIZE;
  return GNUNET_OK;
}
 
 
static void
handle_client_start (void *cls, const struct StartMessage *start)
{
  // const struct GNUNET_PeerIdentity *my_identity;
  struct TransportClient *tc = cls;
  // uint32_t options;
  //
  // my_identity = GNUNET_PILS_get_identity (pils);
  // GNUNET_assert (my_identity);
  //
  // FIXME ignore the check of the peer ids for now.
  //       (also deprecate the old way of obtaining our own peer ID)
  // options = ntohl (start->options);
  // if ((0 != (1 & options)) &&
  //    (0 != GNUNET_memcmp (&start->self, my_identity)))
  // {
  //  /* client thinks this is a different peer, reject */
  //  GNUNET_break (0);
  //  GNUNET_SERVICE_client_drop (tc->client);
  //  return;
  // }
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  tc->type = CT_CORE;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New CORE client with PID %s registered\n",
              GNUNET_i2s (&start->self));
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &notify_client_connect_info,
                                         tc);
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &resume_communicators,
                                         NULL);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static int
check_client_send (void *cls, const struct OutboundMessage *obm)
{
  struct TransportClient *tc = cls;
  uint16_t size;
  const struct GNUNET_MessageHeader *obmm;
 
  if (CT_CORE != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
  if (size < sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
  if (size != ntohs (obmm->size))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
client_send_response (struct PendingMessage *pm)
{
  struct TransportClient *tc = pm->client;
  struct VirtualLink *vl = pm->vl;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "client send response\n");
  if (NULL != tc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Confirming transmission of <%" PRIu64 "> to %s\n",
                pm->logging_uuid,
                GNUNET_i2s (&vl->target));
    credit_client (pm);
  }
  free_pending_message (pm);
}
 
 
static unsigned int
pick_random_dv_hops (const struct DistanceVector *dv,
                     enum RouteMessageOptions options,
                     struct DistanceVectorHop **hops_array,
                     unsigned int hops_array_length)
{
  uint64_t choices[hops_array_length];
  uint64_t num_dv;
  unsigned int dv_count;
 
  /* Pick random vectors, but weighted by distance, giving more weight
     to shorter vectors */
  num_dv = 0;
  dv_count = 0;
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
         .rel_value_us == 0))
      continue;   /* pos unconfirmed and confirmed required */
    /* A hop at (or past) the limit has weight zero -- past it, unsigned
       arithmetic makes the weight huge.  Either way it can never be picked
       below, so it must not be counted: the sampling loop draws
       @a hops_array_length distinct values out of @e num_dv, and counting a
       hop that contributes nothing to @e num_dv can leave it with fewer
       values than draws, which never terminates.  #learn_dv_path() caps
       @e distance well below the limit today, so this is defence in depth. */
    if (pos->distance >= MAX_DV_HOPS_ALLOWED)
      continue;
    num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
    dv_count++;
  }
  if (0 == dv_count)
    return 0;
  if (dv_count <= hops_array_length)
  {
    dv_count = 0;
    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
         pos = pos->next_dv)
      hops_array[dv_count++] = pos;
    return dv_count;
  }
  for (unsigned int i = 0; i < hops_array_length; i++)
  {
    int ok = GNUNET_NO;
    unsigned int tries = 0;
 
    while (GNUNET_NO == ok)
    {
      choices[i] =
        GNUNET_CRYPTO_random_u64 (num_dv);
      ok = GNUNET_YES;
      for (unsigned int j = 0; j < i; j++)
        if (choices[i] == choices[j])
        {
          ok = GNUNET_NO;
          break;
        }
      /* Give up rather than spin: with weight >= 2 per hop the expected
         number of draws per pick is below four, so this many failures is a
         set we cannot sample distinctly.  Returning fewer paths is a routing
         nuisance, hanging here is a deaf service; and a duplicated choice
         would at worst repeat a path, so stopping is safe. */
      if (MAX_DV_PICK_TRIES < ++tries)
        break;
    }
    if (GNUNET_NO == ok)
    {
      hops_array_length = i;
      break;
    }
  }
  dv_count = 0;
  num_dv = 0;
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    uint64_t delta;
 
    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
         .rel_value_us == 0))
      continue;   /* pos unconfirmed and confirmed required */
    if (pos->distance >= MAX_DV_HOPS_ALLOWED)
      continue;   /* zero weight: not counted in @e num_dv above either */
    delta = MAX_DV_HOPS_ALLOWED - pos->distance;
    for (unsigned int i = 0; i < hops_array_length; i++)
      if ((num_dv <= choices[i]) && (num_dv + delta > choices[i]))
        hops_array[dv_count++] = pos;
    num_dv += delta;
  }
  return dv_count;
}
 
 
static int
check_communicator_available (
  void *cls,
  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
{
  struct TransportClient *tc = cls;
  uint16_t size;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  tc->type = CT_COMMUNICATOR;
  size = ntohs (cam->header.size) - sizeof(*cam);
  if (0 == size)
    return GNUNET_OK; /* receive-only communicator */
  GNUNET_MQ_check_zero_termination (cam);
  return GNUNET_OK;
}
 
 
static void
send_cmc_ack (struct CommunicatorMessageContext *cmc)
{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_IncomingMessageAck *ack;
 
  if (GNUNET_YES == cmc->ack_sent)
    return;
  cmc->ack_sent = GNUNET_YES;
  if (NULL == cmc->tc)
    return;   /* communicator is gone, see #detach_cmcs_from_client() */
  if (0 == ntohl (cmc->im.fc_on))
    return;   /* communicator did not ask for flow control */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Acknowledge message with flow control id %" PRIu64 "\n",
              cmc->im.fc_id);
  env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK);
  ack->reserved = htonl (0);
  ack->fc_id = cmc->im.fc_id;
  ack->sender = cmc->im.neighbour_sender;
  GNUNET_MQ_send (cmc->tc->mq, env);
}
 
 
static void
resume_cmc_client (struct CommunicatorMessageContext *cmc)
{
  if (GNUNET_YES == cmc->client_resumed)
    return;
  cmc->client_resumed = GNUNET_YES;
  if (NULL == cmc->tc)
    return;   /* communicator is gone, see #detach_cmcs_from_client() */
  GNUNET_SERVICE_client_continue (cmc->tc->client);
}
 
 
static void
finish_cmc_handling_with_continue (struct CommunicatorMessageContext *cmc,
                                   unsigned
                                   int free_cmc)
{
  send_cmc_ack (cmc);
  resume_cmc_client (cmc);
  if (GNUNET_YES == free_cmc)
  {
    GNUNET_free (cmc);
  }
}
 
 
static void
release_stalled_cmc (struct VirtualLink *vl,
                     struct CommunicatorMessageContext *cmc)
{
  GNUNET_CONTAINER_DLL_remove (vl->cmc_head, vl->cmc_tail, cmc);
  GNUNET_assert (0 < vl->cmc_count);
  vl->cmc_count--;
  finish_cmc_handling_with_continue (cmc, GNUNET_YES);
}
 
 
static void
finish_cmc_handling (struct CommunicatorMessageContext *cmc)
{
  finish_cmc_handling_with_continue (cmc, GNUNET_YES);
}
 
 
static void
handle_client_recv_ok (void *cls, const struct RecvOkMessage *rom)
{
  struct TransportClient *tc = cls;
  struct VirtualLink *vl;
  uint32_t delta;
  struct CommunicatorMessageContext *cmc;
 
  if (CT_CORE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  vl = lookup_virtual_link (&rom->peer);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# RECV_OK dropped: virtual link unknown",
                              1,
                              GNUNET_NO);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  delta = ntohl (rom->increase_window_delta);
  vl->core_recv_window += delta;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "CORE ack receiving message, increased CORE recv window to %d\n",
              vl->core_recv_window);
  GNUNET_SERVICE_client_continue (tc->client);
  if (vl->core_recv_window <= 0)
    return;
  /* release the flow control credit we withheld from the communicators */
  while (NULL != (cmc = vl->cmc_tail))
    release_stalled_cmc (vl, cmc);
  if (NULL != vl->core_fc_stall_task)
  {
    GNUNET_SCHEDULER_cancel (vl->core_fc_stall_task);
    vl->core_fc_stall_task = NULL;
  }
}
 
 
static void
handle_communicator_available (
  void *cls,
  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct TransportClient *tc = cls;
  uint16_t size;
 
  size = ntohs (cam->header.size) - sizeof(*cam);
  if (0 == size)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Receive-only communicator connected\n");
    /* Receive-only communicator: it has no address prefix, but we still
       MUST resume the client or we will never read from it again.  Use an
       empty prefix so that the various strcmp()s do not see NULL. */
    tc->details.communicator.address_prefix = GNUNET_strdup ("");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  tc->details.communicator.address_prefix =
    GNUNET_strdup ((const char *) &cam[1]);
  tc->details.communicator.cc = ntohl (cam->cc);
  tc->details.communicator.can_burst = ntohl (cam->can_burst);
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL != my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Communicator for peer %s with prefix '%s' connected %s\n",
                GNUNET_i2s (my_identity),
                tc->details.communicator.address_prefix,
                tc->details.communicator.can_burst ? "can burst" :
                "can not burst");
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Communicator for local peer with prefix '%s' connected %s\n",
                tc->details.communicator.address_prefix,
                tc->details.communicator.can_burst ? "can burst" :
                "can not burst");
  }
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static int
check_communicator_backchannel (
  void *cls,
  const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
{
  const struct GNUNET_MessageHeader *inbox;
  const char *is;
  uint16_t msize;
  uint16_t isize;
 
  (void) cls;
  msize = ntohs (cb->header.size) - sizeof(*cb);
  inbox = (const struct GNUNET_MessageHeader *) &cb[1];
  /* MUST bound the buffer before dereferencing @a inbox. */
  if (msize <= sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  isize = ntohs (inbox->size);
  if (isize >= msize)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  is = (const char *) inbox;
  is += isize;
  msize -= isize;
  GNUNET_assert (0 < msize);
  if ('\0' != is[msize - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static enum GNUNET_GenericReturnValue
sign_ephemeral (struct DistanceVector *dv)
{
  struct EphemeralConfirmationPS ec;
 
  dv->monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  dv->ephemeral_validity =
    GNUNET_TIME_absolute_add (dv->monotime, EPHEMERAL_VALIDITY);
  ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
  ec.target = dv->target;
  ec.ephemeral_key = dv->ephemeral_key;
  ec.sender_monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
  ec.purpose.size = htonl (sizeof(ec));
  return sign_by_my_identity (&ec.purpose, &dv->sender_sig);
}
 
 
static void
free_queue_entry (struct QueueEntry *qe,
                  struct TransportClient *tc);
 
 
static void
free_timedout_queue_entry (void *cls)
{
  struct TransportClient *tc = cls;
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "freeing timedout queue entries\n");
 
  tc->details.communicator.free_queue_entry_task = NULL;
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    struct QueueEntry *qep = queue->queue_head;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "checking QID %u for timedout queue entries\n",
                queue->qid);
    while (NULL != qep)
    {
      struct QueueEntry *pos = qep;
      struct GNUNET_TIME_Relative diff = GNUNET_TIME_absolute_get_difference (
        pos->creation_timestamp, now);
      qep = qep->next;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "diff to now %s \n",
                  GNUNET_TIME_relative2s (diff, GNUNET_NO));
      if (GNUNET_TIME_relative_cmp (QUEUE_ENTRY_TIMEOUT, <, diff))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Freeing timed out QueueEntry with MID %" PRIu64
                    " and QID %u\n",
                    pos->mid,
                    queue->qid);
        GNUNET_STATISTICS_update (GST_stats,
                                  "# QueueEntries timed out",
                                  1,
                                  GNUNET_NO);
        free_queue_entry (pos, tc);
      }
    }
  }
  /* Entries younger than #QUEUE_ENTRY_TIMEOUT are still to be reclaimed, and
     this task used to be a one-shot armed only by #queue_send_msg().  So the
     sweep that was supposed to bound how long an unacknowledged entry holds
     its slot only ever ran while *new* messages were being queued -- exactly
     not the case once the throttles in #schedule_transmit_on_queue() have
     stopped transmission.  Keep going as long as anything is outstanding. */
  arm_free_queue_entry_task (tc);
}
 
 
static void
arm_free_queue_entry_task (struct TransportClient *tc)
{
  if (NULL != tc->details.communicator.free_queue_entry_task)
    return;
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    if (NULL == queue->queue_head)
      continue;
    tc->details.communicator.free_queue_entry_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                    &free_timedout_queue_entry,
                                    tc);
    return;
  }
}
 
 
static void
queue_send_msg (struct Queue *queue,
                struct PendingMessage *pm,
                const void *payload,
                size_t payload_size)
{
  struct Neighbour *n = queue->neighbour;
  struct GNUNET_TRANSPORT_SendMessageTo *smt;
  struct GNUNET_MQ_Envelope *env;
  struct PendingAcknowledgement *pa;
 
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Queueing %u bytes of payload for transmission <%" PRIu64
    "> on queue %llu to %s\n",
    (unsigned int) payload_size,
    (NULL == pm) ? 0 : pm->logging_uuid,
    (unsigned long long) queue->qid,
    GNUNET_i2s (&queue->neighbour->pid));
  env = GNUNET_MQ_msg_extra (smt,
                             payload_size,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG);
  smt->qid = htonl (queue->qid);
  smt->mid = GNUNET_htonll (queue->mid_gen);
  smt->receiver = n->pid;
  memcpy (&smt[1], payload, payload_size);
  {
    /* Pass the env to the communicator of queue for transmission. */
    struct QueueEntry *qe;
 
    qe = GNUNET_new (struct QueueEntry);
    qe->creation_timestamp = GNUNET_TIME_absolute_get ();
    qe->mid = queue->mid_gen;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Create QueueEntry with MID %" PRIu64
                " and QID %u and prefix %s\n",
                qe->mid,
                queue->qid,
                queue->tc->details.communicator.address_prefix);
    queue->mid_gen++;
    qe->queue = queue;
    if (NULL != pm)
    {
      qe->pm = pm;
      // TODO Why do we have a retransmission. When we know, make decision if we still want this.
      // GNUNET_assert (NULL == pm->qe);
      if (NULL != pm->qe)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Retransmitting message <%" PRIu64
                    "> remove pm from qe with MID: %llu \n",
                    pm->logging_uuid,
                    (unsigned long long) pm->qe->mid);
        pm->qe->pm = NULL;
      }
      pm->qe = qe;
    }
    GNUNET_assert (CT_COMMUNICATOR == queue->tc->type);
    if (0 == queue->q_capacity)
    {
      // Messages without FC or fragments can get here.
      if (NULL != pm)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Message %" PRIu64
                    " (pm type %u) was not send because queue has no capacity.\n",
                    pm->logging_uuid,
                    pm->pmt);
        pm->qe = NULL;
      }
      GNUNET_free (env);
      GNUNET_free (qe);
      return;
    }
    GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe);
    queue->queue_length++;
    queue->tc->details.communicator.total_queue_length++;
    if (GNUNET_NO == queue->unlimited_length)
      queue->q_capacity--;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Queue %s with qid %u has capacity %" PRIu64 "\n",
                queue->address,
                queue->qid,
                queue->q_capacity);
    if (COMMUNICATOR_TOTAL_QUEUE_LIMIT ==
        queue->tc->details.communicator.total_queue_length)
      queue->idle = GNUNET_NO;
    if (QUEUE_LENGTH_LIMIT == queue->queue_length)
      queue->idle = GNUNET_NO;
    if (0 == queue->q_capacity)
      queue->idle = GNUNET_NO;
 
    if (GNUNET_NO == queue->idle)
      arm_free_queue_entry_task (queue->tc);
    if (NULL != pm)
    {
      /* NOTE: @e next_pa was never the link of this list -- nothing ever
         assigned it, so it was NULL on every entry.  The MDLL that
         #prepare_pending_acknowledgement() inserts into is keyed `pm', and
         thus threaded through @e next_pm.  Walking @e next_pa dereferenced
         NULL the moment the head was not the entry we wanted. */
      for (pa = pm->pa_head; NULL != pa; pa = pa->next_pm)
        if (pm == pa->pm)
        {
          pa->num_send++;
          break;
        }
    }
    // GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending message MID %" PRIu64
                " of type %u (%u) and size %lu with MQ %p queue %s (QID %u) pending %"
                PRIu64 "\n",
                GNUNET_ntohll (smt->mid),
                ntohs (((const struct GNUNET_MessageHeader *) payload)->type),
                ntohs (smt->header.size),
                (unsigned long) payload_size,
                queue->tc->mq,
                queue->address,
                queue->qid,
                (NULL == pm) ? 0 : pm->logging_uuid);
    GNUNET_MQ_send (queue->tc->mq, env);
  }
}
 
 
static struct GNUNET_TIME_Relative
route_via_neighbour (const struct Neighbour *n,
                     const struct GNUNET_MessageHeader *hdr,
                     enum RouteMessageOptions options)
{
  struct GNUNET_TIME_Absolute now;
  unsigned int candidates;
  unsigned int sel1;
  unsigned int sel2;
  struct GNUNET_TIME_Relative rtt;
 
  /* Pick one or two 'random' queues from n (under constraints of options) */
  now = GNUNET_TIME_absolute_get ();
  /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to
     weight in the future; weight could be assigned by observed
     bandwidth (note: not sure if we should do this for this type
     of control traffic though). */
  candidates = 0;
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
        (pos->validated_until.abs_value_us > now.abs_value_us))
      candidates++;
  }
  if (0 == candidates)
  {
    /* This can happen rarely if the last confirmed queue timed
       out just as we were beginning to process this message. */
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Could not route message of type %u to %s: no valid queue\n",
                ntohs (hdr->type),
                GNUNET_i2s (&n->pid));
    GNUNET_STATISTICS_update (GST_stats,
                              "# route selection failed (all no valid queue)",
                              1,
                              GNUNET_NO);
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
 
  rtt = GNUNET_TIME_UNIT_FOREVER_REL;
  sel1 = GNUNET_CRYPTO_random_u32 (candidates);
  if (0 == (options & RMO_REDUNDANT))
    sel2 = candidates; /* picks none! */
  else
    sel2 = GNUNET_CRYPTO_random_u32 (candidates);
  candidates = 0;
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
        (pos->validated_until.abs_value_us > now.abs_value_us))
    {
      if ((sel1 == candidates) || (sel2 == candidates))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Routing message of type %u to %s using %s (#%u)\n",
                    ntohs (hdr->type),
                    GNUNET_i2s (&n->pid),
                    pos->address,
                    (sel1 == candidates) ? 1 : 2);
        rtt = GNUNET_TIME_relative_min (rtt, pos->pd.aged_rtt);
        queue_send_msg (pos, NULL, hdr, ntohs (hdr->size));
      }
      candidates++;
    }
  }
  return rtt;
}
 
 
typedef void (*DVMessageHandler) (void *cls,
                                  struct Neighbour *next_hop,
                                  const struct GNUNET_MessageHeader *hdr,
                                  enum RouteMessageOptions options);
 
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)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct TransportDVBoxMessage box_hdr;
  struct TransportDVBoxPayloadP *payload_hdr;
  uint16_t body_len_hbo = ntohs (hdr->size);
  unsigned char pt[sizeof(struct TransportDVBoxPayloadP) + body_len_hbo]
  GNUNET_ALIGN;
  unsigned char ct[sizeof(struct TransportDVBoxPayloadP) + body_len_hbo]
  GNUNET_ALIGN;
  struct GNUNET_TIME_Relative rtt;
  struct GNUNET_CRYPTO_AeadSecretKey km;
 
  payload_hdr = (struct TransportDVBoxPayloadP*) pt;
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  /* Encrypt payload */
  memset (&box_hdr, 0, sizeof (box_hdr));
  box_hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
  box_hdr.total_hops = htons (0);
  box_hdr.without_fc = htonl (without_fc);
  // update_ephemeral (dv);
  if ((0 ==
       GNUNET_TIME_absolute_get_remaining (dv->ephemeral_validity).rel_value_us)
      || (NULL == dv->km))
  {
    GNUNET_CRYPTO_eddsa_kem_encaps (&dv->target.public_key,
                                    &dv->ephemeral_key,
                                    (struct GNUNET_ShortHashCode*) &km);
    GNUNET_free (dv->km);   /* do not leak the previous key material */
    dv->km = GNUNET_new (struct GNUNET_ShortHashCode);
    GNUNET_memcpy (dv->km, &km, sizeof(struct GNUNET_ShortHashCode));
    if (GNUNET_OK != sign_ephemeral (dv))
    {
      /* Without a matching signature the box is undecryptable noise to the
         receiver; do not spend the bandwidth.  Expire the ephemeral so the
         next attempt re-derives and re-signs rather than reusing it. */
      dv->ephemeral_validity = GNUNET_TIME_UNIT_ZERO_ABS;
      return GNUNET_TIME_UNIT_FOREVER_REL;
    }
  }
  else
  {
    /* The ephemeral key is still valid, so reuse the cached key material.
       Without this @a km stayed UNINITIALISED stack memory and the
       receiver could not decrypt the box. */
    GNUNET_memcpy (&km, dv->km, sizeof(struct GNUNET_ShortHashCode));
  }
  box_hdr.ephemeral_key = dv->ephemeral_key;
  payload_hdr->sender_sig = dv->sender_sig;
  memcpy (&payload_hdr[1], hdr, body_len_hbo);
  GNUNET_CRYPTO_random_block (&box_hdr.iv,
                              sizeof(box_hdr.iv));
  payload_hdr->sender = *my_identity;
  payload_hdr->monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
  GNUNET_CRYPTO_aead_encrypt (sizeof pt,
                              pt,
                              0,
                              NULL,
                              &km,
                              &box_hdr.iv,
                              ct,
                              &box_hdr.mac);
  rtt = GNUNET_TIME_UNIT_FOREVER_REL;
  /* For each selected path, take the pre-computed header and body
     and add the path in the middle of the message; then send it. */
  for (unsigned int i = 0; i < num_dvhs; i++)
  {
    struct DistanceVectorHop *dvh = dvhs[i];
    unsigned int num_hops = dvh->distance + 1;
    char buf[sizeof(struct TransportDVBoxMessage)
             + sizeof(struct GNUNET_PeerIdentity) * num_hops
             + sizeof(struct TransportDVBoxPayloadP)
             + body_len_hbo] GNUNET_ALIGN;
    struct GNUNET_PeerIdentity *dhops;
 
    box_hdr.header.size = htons (sizeof(buf));
    box_hdr.orig_size = htons (sizeof(buf));
    box_hdr.num_hops = htons (num_hops);
    memcpy (buf, &box_hdr, sizeof(box_hdr));
    dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)];
    memcpy (dhops,
            dvh->path,
            dvh->distance * sizeof(struct GNUNET_PeerIdentity));
    dhops[dvh->distance] = dv->target;
    if (GNUNET_EXTRA_LOGGING > 0)
    {
      char *path;
 
      path = GNUNET_strdup (GNUNET_i2s (my_identity));
      for (unsigned int j = 0; j < num_hops; j++)
      {
        char *tmp;
 
        GNUNET_asprintf (&tmp, "%s-%s", path, GNUNET_i2s (&dhops[j]));
        GNUNET_free (path);
        path = tmp;
      }
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Routing message of type %u to %s using DV (#%u/%u) via %s\n",
                  ntohs (hdr->type),
                  GNUNET_i2s (&dv->target),
                  i + 1,
                  num_dvhs,
                  path);
      GNUNET_free (path);
    }
    rtt = GNUNET_TIME_relative_min (rtt, dvh->pd.aged_rtt);
    memcpy (&dhops[num_hops], ct, sizeof(ct));
    use (use_cls,
         dvh->next_hop,
         (const struct GNUNET_MessageHeader *) buf,
         options);
  }
  return rtt;
}
 
 
static void
send_dv_to_neighbour (void *cls,
                      struct Neighbour *next_hop,
                      const struct GNUNET_MessageHeader *hdr,
                      enum RouteMessageOptions options)
{
  (void) cls;
  (void) route_via_neighbour (next_hop, hdr, RMO_UNCONFIRMED_ALLOWED);
}
 
 
static struct GNUNET_TIME_Relative
route_control_message_without_fc (struct VirtualLink *vl,
// route_control_message_without_fc (const struct GNUNET_PeerIdentity *target,
                                  const struct GNUNET_MessageHeader *hdr,
                                  enum RouteMessageOptions options)
{
  // struct VirtualLink *vl;
  struct Neighbour *n;
  struct DistanceVector *dv;
  struct GNUNET_TIME_Relative rtt1;
  struct GNUNET_TIME_Relative rtt2;
  const struct GNUNET_PeerIdentity *target = &vl->target;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Trying to route message of type %u to %s without fc\n",
              ntohs (hdr->type),
              GNUNET_i2s (target));
 
  // TODO Do this elsewhere. vl should be given as parameter to method.
  // vl = lookup_virtual_link (target);
  /* An unconfirmed link is allowed here: it has no @e n and no @e dv of its
     own, so the "confirmed required" branch below resolves the route from
     #neighbours / #dv_routes.  Refusing to route at all is what deadlocks a
     pair of peers, see #consider_sending_fc(). */
  GNUNET_assert (NULL != vl);
  n = vl->n;
  dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL;
  /* An unconfirmed link has neither @e n nor @e dv of its own, so resolve
     the route from #neighbours / #dv_routes.  This used to be done only
     while #RMO_UNCONFIRMED_ALLOWED was *not* set -- exactly backwards: with
     the flag set (the caller that needs it most) we would find no route at
     all and drop the message.  Whether an unvalidated queue or an
     unvalidated path may then be used is still decided by @a options, in
     #route_via_neighbour() and #pick_random_dv_hops(). */
  if (NULL == n)
    n = lookup_neighbour (target);
  if ((NULL == dv) && (0 != (options & RMO_DV_ALLOWED)))
    dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, target);
  if ((NULL == n) && (NULL == dv))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Cannot route message of type %u to %s: no route\n",
                ntohs (hdr->type),
                GNUNET_i2s (target));
    GNUNET_STATISTICS_update (GST_stats,
                              "# Messages dropped in routing: no acceptable method",
                              1,
                              GNUNET_NO);
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Routing message of type %u to %s with options %X\n",
              ntohs (hdr->type),
              GNUNET_i2s (target),
              (unsigned int) options);
  /* If both dv and n are possible and we must choose:
     flip a coin for the choice between the two; for now 50/50 */
  if ((NULL != n) && (NULL != dv) && (0 == (options & RMO_REDUNDANT)))
  {
    if (0 == GNUNET_CRYPTO_random_u32 (2))
      n = NULL;
    else
      dv = NULL;
  }
  if ((NULL != n) && (NULL != dv))
    options &= ~RMO_REDUNDANT; /* We will do one DV and one direct, that's
                                  enough for redundancy, so clear the flag. */
  rtt1 = GNUNET_TIME_UNIT_FOREVER_REL;
  rtt2 = GNUNET_TIME_UNIT_FOREVER_REL;
  if (NULL != n)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Try to route message of type %u to %s without fc via neighbour\n",
                ntohs (hdr->type),
                GNUNET_i2s (target));
    rtt1 = route_via_neighbour (n, hdr, options);
  }
  if (NULL != dv)
  {
    struct DistanceVectorHop *hops[2];
    unsigned int res;
 
    res = pick_random_dv_hops (dv,
                               options,
                               hops,
                               (0 == (options & RMO_REDUNDANT)) ? 1 : 2);
    if (0 == res)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Failed to route message, could not determine DV path\n");
      return rtt1;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "encapsulate_for_dv 1\n");
    rtt2 = encapsulate_for_dv (dv,
                               res,
                               hops,
                               hdr,
                               &send_dv_to_neighbour,
                               NULL,
                               options & (~RMO_REDUNDANT),
                               GNUNET_YES);
  }
  return GNUNET_TIME_relative_min (rtt1, rtt2);
}
 
 
static void
consider_sending_fc (void *cls);
 
static void
task_consider_sending_fc (void *cls)
{
  struct VirtualLink *vl = cls;
  vl->fc_retransmit_task = NULL;
  consider_sending_fc (cls);
}
 
 
static char *
get_address_without_port (const char *address);
 
 
struct AddGlobalAddressesContext
{
  size_t off;
 
  size_t size;
 
  char *tgnas;
};
 
 
static enum GNUNET_GenericReturnValue
add_global_addresses (void *cls,
                      const struct GNUNET_PeerIdentity *pid,
                      void *value)
{
  struct AddGlobalAddressesContext *ctx = cls;
  struct TransportGlobalNattedAddress *tgna = value;
  char *addr = (char *) &tgna[1];
  size_t alen = ntohl (tgna->address_length);
  size_t need = sizeof (struct TransportGlobalNattedAddress) + alen;
 
  /* NOTE: the address is NOT 0-terminated, it must be printed with an
     explicit precision. */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "sending address %.*s length %lu\n",
              (int) alen,
              addr,
              (unsigned long) alen);
  if (ctx->off + need > ctx->size)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  GNUNET_memcpy (&(ctx->tgnas[ctx->off]), tgna, need);
  ctx->off += need;
 
  return GNUNET_OK;
}
 
 
static struct GNUNET_TIME_Relative
calculate_rtt (struct DistanceVector *dv);
 
 
static void
consider_sending_fc (void *cls)
{
  struct VirtualLink *vl = cls;
  struct GNUNET_TIME_Absolute monotime;
  struct TransportFlowControlMessage *fc;
  struct GNUNET_TIME_Relative duration;
  struct GNUNET_TIME_Relative rtt;
  struct GNUNET_TIME_Relative rtt_average;
  struct Neighbour *n = vl->n;
  size_t addresses_size;
 
  /* Most of our callers are not the retransmit task but inbound events:
     handle_flow_control() ends in check_vl_transmission(), which calls us
     once per flow-control-stalled message, and the peer's answer to what we
     send here arrives as another handle_flow_control().  On a link whose
     head message does not fit the window that is a ping-pong with nothing
     to damp it -- the backoff and the MIN_FC_RETRANSMIT_DELAY floor at the
     bottom of this function only ever governed @e fc_retransmit_task, which
     these callers bypass.  If the chain is armed and we just sent one, let
     the task do it. */
  if ((NULL != vl->fc_retransmit_task) &&
      (GNUNET_TIME_absolute_get_duration (vl->last_fc_transmission).rel_value_us
       < MIN_FC_RETRANSMIT_DELAY.rel_value_us))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Not sending FC to %s: one went out less than %s ago\n",
                GNUNET_i2s (&vl->target),
                GNUNET_STRINGS_relative_time_to_string (
                  MIN_FC_RETRANSMIT_DELAY,
                  GNUNET_YES));
    return;
  }
  if ((GNUNET_YES != vl->confirmed) &&
      (NULL == lookup_neighbour (&vl->target)) &&
      (NULL == GNUNET_CONTAINER_multipeermap_get (dv_routes, &vl->target)))
  {
    /* Unconfirmed AND no way to reach the peer at all -- nothing to send on.
       An unconfirmed link that *does* have a route must still answer,
       see below.
 
       Do NOT just return: #task_consider_sending_fc() cleared
       @e fc_retransmit_task before calling us, and the only other place that
       arms it is #handle_flow_control() -- which only does so when it is
       already non-NULL.  Leaving without re-arming therefore ends the
       keepalive chain for this link permanently, and #check_link_down()
       tears it down #NEIGHBOUR_LIVENESS_TIMEOUT later. */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Not sending FC to %s: link unconfirmed and no route\n",
                GNUNET_i2s (&vl->target));
    if (NULL == vl->fc_retransmit_task)
      vl->fc_retransmit_task =
        GNUNET_SCHEDULER_add_delayed (FC_KEEPALIVE_INTERVAL,
                                      &task_consider_sending_fc,
                                      vl);
    return;
  }
  addresses_size = 0;
  if (NULL != n && 0 < n->number_of_addresses)
  {
    addresses_size =
      n->number_of_addresses * sizeof (struct TransportGlobalNattedAddress) + n
      ->size_of_global_addresses;
    if (addresses_size >
        UINT16_MAX - sizeof (struct TransportFlowControlMessage))
    {
      /* htons() below would silently truncate `header.size', leaving a
         message whose declared length does not match its contents. */
      GNUNET_break (0);
      addresses_size = 0;
    }
  }
  if (0 != addresses_size)
  {
    char *tgnas = GNUNET_malloc (addresses_size);
    struct AddGlobalAddressesContext ctx;
    ctx.off = 0;
    ctx.size = addresses_size;
    ctx.tgnas = tgnas;
 
    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage)
                        + addresses_size);
    fc->header.size = htons (sizeof(struct TransportFlowControlMessage)
                             + addresses_size);
    fc->size_of_addresses = htonl ((uint32_t) n->size_of_global_addresses);
    fc->number_of_addresses = htonl (n->number_of_addresses);
    GNUNET_CONTAINER_multipeermap_iterate (n->natted_addresses,
                                           &add_global_addresses,
                                           &ctx);
    GNUNET_memcpy (&fc[1], tgnas, addresses_size);
    GNUNET_free (tgnas);
  }
  else
  {
    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage));
    fc->header.size = htons (sizeof(struct TransportFlowControlMessage));
  }
 
  duration = GNUNET_TIME_absolute_get_duration (vl->last_fc_transmission);
  /* OPTIMIZE-FC-BDP: decide sane criteria on when to do this, instead of doing
     it always! */
  /* For example, we should probably ONLY do this if a bit more than
     an RTT has passed, or if the window changed "significantly" since
     then. See vl->last_fc_rtt! NOTE: to do this properly, we also
     need an estimate for the bandwidth-delay-product for the entire
     VL, as that determines "significantly". We have the delay, but
     the bandwidth statistics need to be added for the VL!*/(void) duration;
 
  if (NULL != vl->dv)
    rtt_average = calculate_rtt (vl->dv);
  else
    rtt_average = GNUNET_TIME_UNIT_FOREVER_REL;
  fc->rtt = GNUNET_TIME_relative_hton (rtt_average);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending FC seq %u to %s with new window %llu %lu %u\n",
              (unsigned int) vl->fc_seq_gen,
              GNUNET_i2s (&vl->target),
              (unsigned long long) vl->incoming_fc_window_size,
              (unsigned long) rtt_average.rel_value_us,
              vl->sync_ready);
  monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  vl->last_fc_transmission = monotime;
  fc->sync_ready = htonl ((uint32_t) vl->sync_ready);
  fc->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL);
  fc->seq = htonl (vl->fc_seq_gen++);
  fc->inbound_window_size = GNUNET_htonll (vl->incoming_fc_window_size
                                           + vl->incoming_fc_window_size_used
                                           + vl->incoming_fc_window_size_loss);
  fc->outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used);
  fc->outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size);
  fc->sender_time = GNUNET_TIME_absolute_hton (monotime);
  /* On an unconfirmed link the only queues and paths we have are, by
     definition, unvalidated ones -- that is what "unconfirmed" means.
     Requiring a validated route here is what deadlocks the pair: the peer
     has a confirmed link to us and flow-controls us, we cannot answer, so
     its @e outbound_fc_window_size stays at zero and it cannot send us a
     single byte -- not its CORE handshake, not DHT traffic -- while its
     `gnunet-transport' shows an established link with messages pending
     forever.  It reached us over that queue, so answering on it is sound. */
  rtt = route_control_message_without_fc (vl,
                                          &fc->header,
                                          (GNUNET_YES == vl->confirmed)
                                          ? RMO_DV_ALLOWED
                                          : RMO_ANYTHING_GOES);
  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us)
  {
    rtt = GNUNET_TIME_UNIT_SECONDS;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "FC retransmission to %s failed, will retry in %s\n",
                GNUNET_i2s (&vl->target),
                GNUNET_STRINGS_relative_time_to_string (rtt, GNUNET_YES));
    vl->last_fc_rtt = GNUNET_TIME_UNIT_ZERO;
  }
  else
  {
    /* OPTIMIZE-FC-BDP: rtt is not ideal, we can do better! */
    vl->last_fc_rtt = rtt;
  }
  if (NULL != vl->fc_retransmit_task)
    GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
  /* Never re-arm with (near) zero delay: @a rtt is zero whenever we have no
     RTT sample yet, which turned this into a tight send loop. */
  rtt = GNUNET_TIME_relative_max (rtt, MIN_FC_RETRANSMIT_DELAY);
  {
    /* Back off while the peer stays silent.  Retransmitting at the plain RTT
       for #MAX_FC_RETRANSMIT_COUNT rounds is a flood on a link that is not
       being answered -- and a peer that cannot answer keeps *every* one of
       its links in exactly that state, which is enough traffic to make
       transport fall behind its communicators. */
    struct GNUNET_TIME_Relative cap = FC_KEEPALIVE_INTERVAL;
 
    for (unsigned int i = 0;
         (i < vl->fc_retransmit_count) && (rtt.rel_value_us < cap.rel_value_us);
         i++)
      rtt = GNUNET_TIME_relative_multiply (rtt, 2);
    rtt = GNUNET_TIME_relative_min (rtt, cap);
  }
  vl->fc_retransmit_task =
    GNUNET_SCHEDULER_add_delayed (rtt, &task_consider_sending_fc, vl);
  if (MAX_FC_RETRANSMIT_COUNT > vl->fc_retransmit_count)
    vl->fc_retransmit_count++;
  GNUNET_free (fc);
}
 
 
static void
check_vl_transmission (struct VirtualLink *vl)
{
  struct Neighbour *n = vl->n;
  struct DistanceVector *dv = vl->dv;
  struct GNUNET_TIME_Absolute now;
  struct VirtualLink *vl_next_hop;
  int elig;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "check_vl_transmission to target %s\n",
              GNUNET_i2s (&vl->target));
  /* Check that we have an eligible pending message!
     (cheaper than having #transmit_on_queue() find out!) */
  elig = GNUNET_NO;
  for (struct PendingMessage *pm = vl->pending_msg_head; NULL != pm;
       pm = pm->next_vl)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "check_vl_transmission loop\n");
    if (NULL != pm->qe)
      continue;   /* not eligible, is in a queue! */
    if (pm->bytes_msg + vl->outbound_fc_window_size_used >
        vl->outbound_fc_window_size)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Stalled message %" PRIu64
                  " transmission on VL %s due to flow control: %llu < %llu\n",
                  pm->logging_uuid,
                  GNUNET_i2s (&vl->target),
                  (unsigned long long) vl->outbound_fc_window_size,
                  (unsigned long long) (pm->bytes_msg
                                        + vl->outbound_fc_window_size_used));
      consider_sending_fc (vl);
      return;     /* We have a message, but flow control says "nope" */
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Target window on VL %s not stalled. Scheduling transmission on queue\n",
                GNUNET_i2s (&vl->target));
    /* Notify queues at direct neighbours that we are interested */
    now = GNUNET_TIME_absolute_get ();
    if (NULL != n)
    {
      for (struct Queue *queue = n->queue_head; NULL != queue;
           queue = queue->next_neighbour)
      {
        if ((GNUNET_YES == queue->idle) &&
            (queue->validated_until.abs_value_us > now.abs_value_us))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Direct neighbour %s not stalled\n",
                      GNUNET_i2s (&n->pid));
          schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                      queue,
                                      GNUNET_SCHEDULER_PRIORITY_DEFAULT);
          elig = GNUNET_YES;
        }
        else
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Neighbour Queue QID: %u (%u) busy or invalid\n",
                      queue->qid,
                      queue->idle);
      }
    }
    /* Notify queues via DV that we are interested */
    if (NULL != dv)
    {
      /* Do DV with lower scheduler priority, which effectively means that
         IF a neighbour exists and is available, we prefer it. */
      for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
           pos = pos->next_dv)
      {
        struct Neighbour *nh_iter = pos->next_hop;
 
 
        if (pos->path_valid_until.abs_value_us <= now.abs_value_us)
          continue;   /* skip this one: path not validated */
        else
        {
          /* The next hop is a neighbour we have queues to; it need not have
             a virtual link of its own, and then there is no window of it to
             respect either. */
          vl_next_hop = lookup_virtual_link (&nh_iter->pid);
          if ((NULL != vl_next_hop) &&
              (pm->bytes_msg + vl_next_hop->outbound_fc_window_size_used >
               vl_next_hop->outbound_fc_window_size))
          {
            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        "Stalled message %" PRIu64
                        " transmission on next hop %s due to flow control: %llu < %llu\n",
                        pm->logging_uuid,
                        GNUNET_i2s (&vl_next_hop->target),
                        (unsigned long
                         long) vl_next_hop->outbound_fc_window_size,
                        (unsigned long long) (pm->bytes_msg
                                              + vl_next_hop->
                                              outbound_fc_window_size_used));
            consider_sending_fc (vl_next_hop);
            continue; /* We have a message, but flow control says "nope" for the first hop of this path */
          }
          for (struct Queue *queue = nh_iter->queue_head; NULL != queue;
               queue = queue->next_neighbour)
            if ((GNUNET_YES == queue->idle) &&
                (queue->validated_until.abs_value_us > now.abs_value_us))
            {
              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                          "Next hop neighbour %s not stalled\n",
                          GNUNET_i2s (&nh_iter->pid));
              schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                          queue,
                                          GNUNET_SCHEDULER_PRIORITY_BACKGROUND);
              elig = GNUNET_YES;
            }
            else
              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                          "DV Queue QID: %u (%u) busy or invalid\n",
                          queue->qid,
                          queue->idle);
        }
      }
    }
    if (GNUNET_YES == elig)
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Eligible message %" PRIu64 " of size %u to %s: %llu/%llu\n",
                  pm->logging_uuid,
                  pm->bytes_msg,
                  GNUNET_i2s (&vl->target),
                  (unsigned long long) vl->outbound_fc_window_size,
                  (unsigned long long) (pm->bytes_msg
                                        + vl->outbound_fc_window_size_used));
    break;
  }
}
 
 
static void
handle_client_send (void *cls, const struct OutboundMessage *obm)
{
  struct TransportClient *tc = cls;
  struct PendingMessage *pm;
  const struct GNUNET_MessageHeader *obmm;
  uint32_t bytes_msg;
  struct VirtualLink *vl;
  enum GNUNET_MQ_PriorityPreferences pp;
 
  GNUNET_assert (CT_CORE == tc->type);
  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
  bytes_msg = ntohs (obmm->size);
  pp = ntohl (obm->priority);
  vl = lookup_virtual_link (&obm->peer);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Don't have %s as a neighbour (anymore).\n",
                GNUNET_i2s (&obm->peer));
    /* Failure: don't have this peer as a neighbour (anymore).
       Might have gone down asynchronously, so this is NOT
       a protocol violation by CORE. Still count the event,
       as this should be rare. */
    /* Precisely because this is not a protocol violation we leave the
       client's `struct Neighbour' -- and its send window -- in place, so we
       owe it the SEND_OK for the message we are dropping here.  Without it
       the window shrinks by one every time this happens and never grows
       back; after #SEND_WINDOW_SIZE such drops #mq_send_impl() parks every
       further message for this peer forever ("Flow control delays
       transmission to CORE until we see SEND_OK") and CORE goes mute
       towards a peer it still believes it is connected to -- while
       continuing to receive from it, so its own idle timeout is what
       eventually reports the peer down. */
    send_ok_to_client (tc, &obm->peer);
    GNUNET_SERVICE_client_continue (tc->client);
    GNUNET_STATISTICS_update (GST_stats,
                              "# messages dropped (neighbour unknown)",
                              1,
                              GNUNET_NO);
    return;
  }
 
  pm = GNUNET_malloc (sizeof(struct PendingMessage) + bytes_msg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "1 created pm %p storing vl %p\n",
              pm,
              vl);
  pm->logging_uuid = logging_uuid_gen++;
  pm->prefs = pp;
  pm->client = tc;
  pm->vl = vl;
  pm->bytes_msg = bytes_msg;
  memcpy (&pm[1], obmm, bytes_msg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending message of type %u  with %u bytes as <%" PRIu64
              "> to %s\n",
              ntohs (obmm->type),
              bytes_msg,
              pm->logging_uuid,
              GNUNET_i2s (&obm->peer));
  GNUNET_CONTAINER_MDLL_insert (client,
                                tc->details.core.pending_msg_head,
                                tc->details.core.pending_msg_tail,
                                pm);
  GNUNET_CONTAINER_MDLL_insert (vl,
                                vl->pending_msg_head,
                                vl->pending_msg_tail,
                                pm);
  check_vl_transmission (vl);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
handle_communicator_backchannel (
  void *cls,
  const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
{
  struct Neighbour *n;
  struct VirtualLink *vl;
  struct TransportClient *tc = cls;
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &cb[1];
  uint16_t isize = ntohs (inbox->size);
  const char *is = ((const char *) &cb[1]) + isize;
  size_t slen = strlen (is) + 1;
  char
    mbuf[slen + isize
         + sizeof(struct
                  TransportBackchannelEncapsulationMessage)] GNUNET_ALIGN;
  struct TransportBackchannelEncapsulationMessage *be =
    (struct TransportBackchannelEncapsulationMessage *) mbuf;
 
  /* 0-termination of 'is' was checked already in
   #check_communicator_backchannel() */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Preparing backchannel transmission to %s:%s of type %u and size %u\n",
              GNUNET_i2s (&cb->pid),
              is,
              ntohs (inbox->type),
              ntohs (inbox->size));
  /* encapsulate and encrypt message */
  be->header.type =
    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION);
  be->header.size = htons (sizeof(mbuf));
  memcpy (&be[1], inbox, isize);
  memcpy (&mbuf[sizeof(struct TransportBackchannelEncapsulationMessage)
                + isize],
          is,
          strlen (is) + 1);
  // route_control_message_without_fc (&cb->pid, &be->header, RMO_DV_ALLOWED);
  vl = lookup_virtual_link (&cb->pid);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    route_control_message_without_fc (vl, &be->header, RMO_DV_ALLOWED);
  }
  else
  {
    /* Use route via neighbour */
    n = lookup_neighbour (&cb->pid);
    if (NULL != n)
      route_via_neighbour (
        n,
        &be->header,
        RMO_NONE);
  }
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static int
check_add_address (void *cls,
                   const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_MQ_check_zero_termination (aam);
  return GNUNET_OK;
}
 
 
static void
store_pi (void *cls);
 
 
struct PilsAddressSignContext
{
 
  struct AddressListEntry *ale;
 
  struct PilsRequest *req;
 
 
  struct GNUNET_TIME_Absolute et;
};
 
 
static void
cancel_address_store (struct AddressListEntry *ale)
{
  struct PilsAddressSignContext *pc = ale->pc;
 
  if (NULL == pc)
    return;
  ale->pc = NULL;
  /* Each stage of the chain passes @a pc as its closure, so every handle
     that could still deliver one has to go before @a pc is released. */
  if (NULL != ale->sc)
  {
    GNUNET_PEERSTORE_store_cancel (ale->sc);
    ale->sc = NULL;
  }
  if (NULL != ale->shc)
  {
    GNUNET_PEERSTORE_hello_add_cancel (ale->shc);
    ale->shc = NULL;
  }
  if (NULL != pc->req)
  {
    if (NULL != pc->req->op)
      GNUNET_PILS_cancel (pc->req->op);
    GNUNET_CONTAINER_DLL_remove (pils_requests_head,
                                 pils_requests_tail,
                                 pc->req);
    GNUNET_free (pc->req);
    pc->req = NULL;
  }
  GNUNET_free (pc);
}
 
 
static void
shc_cont (void *cls, int success)
{
  struct PilsAddressSignContext *pc = cls;
 
  GNUNET_assert (NULL == pc->req);
  /* The store completed; the handle is dead and must not be cancelled
     later by #free_address_list_entry(). */
  pc->ale->shc = NULL;
  pc->ale->pc = NULL;
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to store our address `%s' with peerstore\n",
                pc->ale->address);
    if (NULL == pc->ale->st)
    {
      pc->ale->st = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                  &store_pi,
                                                  pc->ale);
    }
  }
  GNUNET_free (pc);
}
 
 
static void
pils_sign_hello_cb (void *cls,
                    const struct GNUNET_PeerIdentity *pid,
                    const struct GNUNET_CRYPTO_EddsaSignature *sig)
{
  struct PilsAddressSignContext *pc = cls;
  struct GNUNET_MQ_Envelope *env;
  const struct GNUNET_MessageHeader *msg;
 
  pc->req->op = NULL;
  GNUNET_CONTAINER_DLL_remove (pils_requests_head,
                               pils_requests_tail,
                               pc->req);
  GNUNET_free (pc->req);
  pc->req = NULL;
  env = GNUNET_HELLO_builder_to_env (
    GST_my_hello,
    pid,
    sig,
    pc->et);
  msg = GNUNET_MQ_env_get_msg (env);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "store_pi 1\n");
  pc->ale->shc = GNUNET_PEERSTORE_hello_add (peerstore,
                                             msg,
                                             shc_cont,
                                             pc);
  GNUNET_free (env);
}
 
 
static void
peerstore_store_own_cb (void *cls, int success)
{
  struct PilsAddressSignContext *pc = cls;
 
  pc->ale->sc = NULL;
  if (GNUNET_YES != success)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store our own address `%s' in peerstore!\n",
                pc->ale->address);
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Successfully stored our own address `%s' in peerstore!\n",
                pc->ale->address);
  /* refresh period is 1/4 of expiration time, that should be plenty
     without being excessive. */
  if (NULL == pc->ale->st)
  {
    /* @e expiration comes straight off the wire in ADD_ADDRESS and is not
       validated anywhere, so a communicator reporting a very short (or
       zero) lifetime would have us re-sign the HELLO and store it again on
       the next scheduler pass, forever.  That is an EdDSA signature and a
       PEERSTORE round trip per iteration. */
    pc->ale->st =
      GNUNET_SCHEDULER_add_delayed (
        GNUNET_TIME_relative_max (
          MIN_ADDRESS_REFRESH_INTERVAL,
          GNUNET_TIME_relative_divide (pc->ale->expiration,
                                       4ULL)),
        &store_pi,
        pc->ale);
  }
 
  /* Now we have to update our HELLO! */
  pc->et = GNUNET_TIME_relative_to_absolute (GNUNET_HELLO_ADDRESS_EXPIRATION);
  pc->req = GNUNET_new (struct PilsRequest);
  GNUNET_CONTAINER_DLL_insert (pils_requests_head,
                               pils_requests_tail,
                               pc->req);
  pc->req->op = GNUNET_PILS_sign_hello (pils,
                                        GST_my_hello,
                                        pc->et,
                                        &pils_sign_hello_cb,
                                        pc);
}
 
 
static void
store_signed_address (struct PilsAddressSignContext *pc,
                      const struct GNUNET_PeerIdentity *pid,
                      const struct GNUNET_CRYPTO_EddsaSignature *sig)
{
  char *sig_str;
  void *result;
  size_t result_size;
 
  sig_str = NULL;
  (void) GNUNET_STRINGS_base64_encode (sig, sizeof(*sig), &sig_str);
  result_size =
    1 + GNUNET_asprintf (
      (char **) &result,
      "%s;%llu;%u;%s",
      sig_str,
      (unsigned long long) pc->et.abs_value_us,
      (unsigned int) pc->ale->nt,
      pc->ale->address);
  GNUNET_free (sig_str);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Build our HELLO URI `%s'\n",
              (char*) result);
 
  GNUNET_free (pc->ale->signed_address);
  pc->ale->signed_address = result;
  pc->ale->signed_address_len = result_size;
  struct GNUNET_TIME_Absolute expiration;
 
  expiration = GNUNET_TIME_relative_to_absolute (pc->ale->expiration);
  pc->ale->sc = GNUNET_PEERSTORE_store (peerstore,
                                        "transport",
                                        pid,
                                        GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY,
                                        result,
                                        result_size,
                                        expiration,
                                        GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
                                        &peerstore_store_own_cb,
                                        pc);
}
 
 
struct SignedAddress
{
  struct GNUNET_CRYPTO_SignaturePurpose purpose;
 
  struct GNUNET_TIME_AbsoluteNBO mono_time;
 
  struct GNUNET_HashCode addr_hash GNUNET_PACKED;
};
 
 
void
pils_sign_address (
  struct AddressListEntry *ale,
  struct GNUNET_TIME_Absolute mono_time)
{
  struct SignedAddress sa;
  struct PilsAddressSignContext *pc;
  struct GNUNET_CRYPTO_EddsaSignature sig;
  const struct GNUNET_PeerIdentity *my_identity;
 
  sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
  sa.purpose.size = htonl (sizeof(sa));
  sa.mono_time = GNUNET_TIME_absolute_hton (mono_time);
  GNUNET_CRYPTO_hash (ale->address, strlen (ale->address), &sa.addr_hash);
  /* Only ever one chain per entry: the previous one (if any) still holds a
     pointer to @a ale and must be torn down first. */
  cancel_address_store (ale);
  my_identity = GNUNET_PILS_get_identity (pils);
  if ((NULL == my_identity) ||
      (GNUNET_OK != sign_by_my_identity (&sa.purpose, &sig)))
  {
    /* Nothing else re-arms @e st: #store_pi() cleared it before calling us,
       and the only other thing that sets it is #peerstore_store_own_cb(),
       which is on the far side of the store we just failed to start.  So a
       single failure to sign used to end the refresh cycle for this address
       for the rest of the process' life. */
    if (NULL == ale->st)
    {
      ale->pils_backoff = GNUNET_TIME_STD_BACKOFF (ale->pils_backoff);
      ale->st = GNUNET_SCHEDULER_add_delayed (ale->pils_backoff,
                                              &store_pi,
                                              ale);
    }
    return;
  }
  pc = GNUNET_new (struct PilsAddressSignContext);
  pc->ale = ale;
  pc->et = mono_time;
  ale->pc = pc;
  store_signed_address (pc, my_identity, &sig);
}
 
 
static void
store_pi (void *cls)
{
  struct AddressListEntry *ale = cls;
  const char *dash;
  char *address_uri;
  char *prefix;
  unsigned int add_success;
 
  if ((GNUNET_YES == in_shutdown) || (NULL == pils))
  {
    ale->st = NULL;
    return;
  }
  if (NULL == GNUNET_PILS_get_identity (pils))
  {
    /* Do NOT poll at 1kHz: that burns CPU and keeps the scheduler task
       list non-empty, which prevents the service from ever exiting. */
    ale->pils_backoff = GNUNET_TIME_STD_BACKOFF (ale->pils_backoff);
    ale->st = GNUNET_SCHEDULER_add_delayed (ale->pils_backoff,
                                            &store_pi,
                                            ale);
    return;
  }
  ale->pils_backoff = GNUNET_TIME_UNIT_ZERO;
  prefix = GNUNET_HELLO_address_to_prefix (ale->address);
  dash = strchr (ale->address, '-');
  GNUNET_assert (NULL != dash);
  dash++;
  GNUNET_asprintf (&address_uri,
                   "%s://%s",
                   prefix,
                   dash);
  GNUNET_free (prefix);
  ale->st = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Storing our address `%s' in peerstore until %s!\n",
              ale->address,
              GNUNET_STRINGS_absolute_time_to_string (hello_mono_time));
  add_success = GNUNET_HELLO_builder_add_address (GST_my_hello,
                                                  address_uri);
  /* NOTE: #GNUNET_HELLO_builder_add_address() answers GNUNET_NO for an
     address that is already in the builder, and on every call after the
     first one for a given address that is exactly what happens: nothing
     ever removes an address from @a GST_my_hello except
     #handle_del_address().  This function is the *refresh* cycle --
     #peerstore_store_own_cb() re-arms it at a quarter of the address'
     expiration -- so bailing out on GNUNET_NO here stopped the refresh
     after precisely one round.  Our own HELLO then expired
     (#GNUNET_HELLO_ADDRESS_EXPIRATION, twelve hours) and was never
     renewed: peers can no longer learn how to reach us, and a link that
     drops after that never comes back.  Only GNUNET_SYSERR -- a malformed
     URI, which retrying cannot fix -- is a reason not to store. */
  if (GNUNET_SYSERR == add_success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Not storing our address `%s': not a valid HELLO URI\n",
                address_uri);
    GNUNET_free (address_uri);
    return;
  }
  GNUNET_log ((GNUNET_NO == add_success) ?
              GNUNET_ERROR_TYPE_DEBUG : GNUNET_ERROR_TYPE_INFO,
              "%s our address `%s' in PEERSTORE\n",
              (GNUNET_NO == add_success) ? "Refreshing" : "Storing",
              address_uri);
  // FIXME hello_mono_time used here?? What about expiration in ale?
  pils_sign_address (ale,
                     hello_mono_time);
  // TODO keep track of op and potentially cancel/clean
  GNUNET_free (address_uri);
}
 
 
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 AddressListEntry *ale;
  char *address_without_port;
 
  ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen);
  ale->tc = tc;
  ale->address = (const char *) &ale[1];
  ale->expiration = expiration;
  ale->aid = aid;
  ale->nt = nt;
  memcpy (&ale[1], address, slen);
  address_without_port = get_address_without_port (ale->address);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Is this %s a local address (%s)\n",
              (NULL == address_without_port) ? "<unparsable>"
              : address_without_port,
              ale->address);
  if ((NULL == address_without_port) ||
      (0 != strcmp ("127.0.0.1", address_without_port)))
  {
    if (NULL != ale->st)
    {
      GNUNET_SCHEDULER_cancel (ale->st);
    }
    ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
  }
  GNUNET_free (address_without_port);
 
  return ale;
}
 
 
static void
feed_addresses_to_pils (void *cls)
{
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Feeding addresses to PILS\n");
  pils_feed_task = NULL;
 
  GNUNET_PILS_feed_addresses (pils,
                              GST_my_hello);
}
 
 
static void
handle_add_address (void *cls,
                    const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
{
  struct TransportClient *tc = cls;
  struct AddressListEntry *ale;
  size_t slen;
  char *address;
 
  /* 0-termination of &aam[1] was checked in #check_add_address */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Communicator added address `%s'!\n",
              (const char *) &aam[1]);
  slen = ntohs (aam->header.size) - sizeof(*aam);
  address = GNUNET_malloc (slen);
  memcpy (address, &aam[1], slen);
  ale = create_address_entry (tc,
                              GNUNET_TIME_relative_ntoh (aam->expiration),
                              ntohl (aam->nt),
                              address,
                              aam->aid,
                              slen);
  GNUNET_CONTAINER_DLL_insert (tc->details.communicator.addr_head,
                               tc->details.communicator.addr_tail,
                               ale);
  {
    for (struct AddressListEntry *iter = tc->details.communicator.addr_head;
         NULL != iter;
         iter = iter->next)
    {
      char *address_uri;
      const char *dash = strchr (iter->address, '-');
      char *prefix = GNUNET_HELLO_address_to_prefix (iter->address);
      GNUNET_assert (NULL != dash);
      dash++;
      GNUNET_asprintf (&address_uri,
                       "%s://%s",
                       prefix,
                       dash);
      GNUNET_free (prefix);
      GNUNET_HELLO_builder_add_address (GST_my_hello, address_uri);
      GNUNET_free (address_uri);
    }
    if (NULL != pils_feed_task)
      GNUNET_SCHEDULER_cancel (pils_feed_task);
    pils_feed_task = GNUNET_SCHEDULER_add_delayed (PILS_FEED_ADDRESSES_DELAY,
                                                   &feed_addresses_to_pils,
                                                   NULL);
  }
  GNUNET_SERVICE_client_continue (tc->client);
  GNUNET_free (address);
}
 
 
static void
handle_del_address (void *cls,
                    const struct GNUNET_TRANSPORT_DelAddressMessage *dam)
{
  struct TransportClient *tc = cls;
  struct AddressListEntry *alen;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  for (struct AddressListEntry *ale = tc->details.communicator.addr_head;
       NULL != ale;
       ale = alen)
  {
    alen = ale->next;
    if (dam->aid != ale->aid)
      continue;
    GNUNET_assert (ale->tc == tc);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Communicator deleted address `%s'!\n",
                ale->address);
    GNUNET_HELLO_builder_del_address (GST_my_hello,
                                      ale->address);
    if (NULL != pils_feed_task)
      GNUNET_SCHEDULER_cancel (pils_feed_task);
    pils_feed_task = GNUNET_SCHEDULER_add_delayed (PILS_FEED_ADDRESSES_DELAY,
                                                   &feed_addresses_to_pils,
                                                   NULL);
    free_address_list_entry (ale);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Communicator removed address we did not even have.\n");
  GNUNET_SERVICE_client_continue (tc->client);
  // GNUNET_SERVICE_client_drop (tc->client);
}
 
 
static void
demultiplex_with_cmc (struct CommunicatorMessageContext *cmc);
 
 
static void
core_env_sent_cb (void *cls)
{
  struct CoreSentContext *ctx = cls;
  struct VirtualLink *vl = ctx->vl;
 
  if (NULL == vl)
  {
    /* lost the link in the meantime, ignore */
    GNUNET_free (ctx);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, ctx);
  GNUNET_assert (vl->incoming_fc_window_size_ram >= ctx->size);
  vl->incoming_fc_window_size_ram -= ctx->size;
  vl->incoming_fc_window_size_used += ctx->isize;
  consider_sending_fc (vl);
  GNUNET_free (ctx);
}
 
 
static void
core_fc_stalled (void *cls)
{
  struct VirtualLink *vl = cls;
  struct CommunicatorMessageContext *cmc;
 
  vl->core_fc_stall_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "CORE did not acknowledge messages from %s within %s; "
              "releasing the flow control credit anyway\n",
              GNUNET_i2s (&vl->target),
              GNUNET_STRINGS_relative_time_to_string (CORE_FC_STALL_TIMEOUT,
                                                      GNUNET_YES));
  GNUNET_STATISTICS_update (GST_stats,
                            "# CORE flow control stalls",
                            1,
                            GNUNET_NO);
  while (NULL != (cmc = vl->cmc_tail))
    release_stalled_cmc (vl, cmc);
  vl->core_recv_window = RECV_WINDOW_SIZE;
  consider_sending_fc (vl);
}
 
 
static void
finish_handling_raw_message (struct VirtualLink *vl,
                             const struct GNUNET_MessageHeader *mh,
                             struct CommunicatorMessageContext *cmc,
                             unsigned int free_cmc)
{
  uint16_t size = ntohs (mh->size);
  int have_core;
 
  if (vl->incoming_fc_window_size_ram > UINT_MAX - size)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (FC arithmetic overflow)",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "CORE messages of type %u with %u bytes dropped (FC arithmetic overflow)\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  if (vl->incoming_fc_window_size_ram + size > vl->available_fc_window_size)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (FC window overflow)",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "CORE messages of type %u with %u bytes dropped (FC window overflow)\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
 
  /* Forward to all CORE clients */
  have_core = GNUNET_NO;
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    struct GNUNET_MQ_Envelope *env;
    struct InboundMessage *im;
    struct CoreSentContext *ctx;
 
    if (CT_CORE != tc->type)
      continue;
    vl->incoming_fc_window_size_ram += size;
    env = GNUNET_MQ_msg_extra (im, size, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
    ctx = GNUNET_new (struct CoreSentContext);
    ctx->vl = vl;
    ctx->size = size;
    ctx->isize = (GNUNET_NO == have_core) ? size : 0;
    have_core = GNUNET_YES;
    GNUNET_CONTAINER_DLL_insert (vl->csc_head, vl->csc_tail, ctx);
    GNUNET_MQ_notify_sent (env, &core_env_sent_cb, ctx);
    im->peer = cmc->im.sender;
    memcpy (&im[1], mh, size);
    GNUNET_MQ_send (tc->mq, env);
    vl->core_recv_window--;
  }
  if (GNUNET_NO == have_core)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Dropped message to CORE: no CORE client connected!\n");
    /* Nevertheless, count window as used, as it is from the
       perspective of the other peer! */
    vl->incoming_fc_window_size_used += size;
    /* TODO-M1 */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Dropped message of type %u with %u bytes to CORE: no CORE client connected!\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Delivered message from %s of type %u to CORE recv window %d\n",
              GNUNET_i2s (&cmc->im.sender),
              ntohs (mh->type),
              vl->core_recv_window);
  if (vl->core_recv_window > 0)
  {
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  /* CORE ran out of receive window for *this* link.  Withhold the
     per-message ACK -- that is what expresses the backpressure -- but
     resume the client immediately.  The client is the communicator
     *process*, which carries every peer we reach through it, and a
     communicator we stop reading from does not stop receiving: it starts
     discarding, see "transport is too slow" in
     #GNUNET_TRANSPORT_communicator_receive().  Discarding is precisely
     what we cannot afford here, because among the messages dropped are
     the ones CORE needs in order to reopen the window it is waiting on. */
  if (GNUNET_YES == free_cmc)
  {
    resume_cmc_client (cmc);
    GNUNET_CONTAINER_DLL_insert (vl->cmc_head, vl->cmc_tail, cmc);
    vl->cmc_count++;
    /* Nothing stalls the producer any more, so bound the list ourselves. */
    while (MAX_STALLED_CMCS < vl->cmc_count)
      release_stalled_cmc (vl, vl->cmc_tail);
    /* ... and do not withhold the ACKs forever: see #core_fc_stalled(). */
    if (NULL == vl->core_fc_stall_task)
      vl->core_fc_stall_task =
        GNUNET_SCHEDULER_add_delayed (CORE_FC_STALL_TIMEOUT,
                                      &core_fc_stalled,
                                      vl);
  }
}
 
 
static void
handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh)
{
  struct CommunicatorMessageContext *cmc = cls;
  // struct CommunicatorMessageContext *cmc_copy =
  // GNUNET_new (struct CommunicatorMessageContext);
  struct GNUNET_MessageHeader *mh_copy;
  struct RingBufferEntry *rbe;
  struct VirtualLink *vl;
  uint16_t size = ntohs (mh->size);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling raw message of type %u with %u bytes\n",
              (unsigned int) ntohs (mh->type),
              (unsigned int) ntohs (mh->size));
 
  if ((size > UINT16_MAX - sizeof(struct InboundMessage)) ||
      (size < sizeof(struct GNUNET_MessageHeader)))
  {
    /* @a mh was unwrapped from what a *remote peer* sent us, so a bad size
       is that peer's protocol violation and says nothing about the
       communicator that carried it.  Dropping the client here disconnects
       the communicator process and with it every neighbour reachable
       through it -- see the rationale in #demultiplex_with_cmc(). */
    GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (bad size)",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  vl = lookup_virtual_link (&cmc->im.sender);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    /* FIXME: sender is giving us messages for CORE but we don't have
       the link up yet! I *suspect* this can happen right now (i.e.
       sender has verified us, but we didn't verify sender), but if
       we pass this on, CORE would be confused (link down, messages
       arrive).  We should investigate more if this happens often,
       or in a persistent manner, and possibly do "something" about
       it. Thus logging as error for now. */
 
    mh_copy = GNUNET_malloc (size);
    rbe = GNUNET_new (struct RingBufferEntry);
    rbe->cmc = cmc;
    /*cmc_copy->tc = cmc->tc;
       cmc_copy->im = cmc->im;*/
    GNUNET_memcpy (mh_copy, mh, size);
 
    rbe->mh = mh_copy;
 
    if (GNUNET_YES == is_ring_buffer_full)
    {
      struct RingBufferEntry *rbe_old = ring_buffer[ring_buffer_head];
      GNUNET_free (rbe_old->cmc);
      GNUNET_free (rbe_old->mh);
      GNUNET_free (rbe_old);
    }
    ring_buffer[ring_buffer_head] = rbe;// cmc_copy;
    // cmc_copy->mh = (const struct GNUNET_MessageHeader *) mh_copy;
    cmc->mh = (const struct GNUNET_MessageHeader *) mh_copy;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Storing message for %s and type %u (%u) in ring buffer head %u is full %u\n",
                GNUNET_i2s (&cmc->im.sender),
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh_copy->type),
                ring_buffer_head,
                is_ring_buffer_full);
    if (RING_BUFFER_SIZE - 1 == ring_buffer_head)
    {
      ring_buffer_head = 0;
      is_ring_buffer_full = GNUNET_YES;
    }
    else
      ring_buffer_head++;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u items stored in ring buffer\n",
                GNUNET_YES == is_ring_buffer_full ? RING_BUFFER_SIZE :
                ring_buffer_head);
 
    /*GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (virtual link still down)",
                              1,
                              GNUNET_NO);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "CORE messages of type %u with %u bytes dropped (virtual link still down)\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    finish_cmc_handling (cmc);*/
    /* @a cmc lives on in the ring buffer; #send_cmc_ack() and
       #resume_cmc_client() have recorded that they ran, so replaying it
       from #send_msg_from_cache() cannot ACK or continue a second time. */
    finish_cmc_handling_with_continue (cmc, GNUNET_NO);
    return;
  }
  finish_handling_raw_message (vl, mh, cmc, GNUNET_YES);
}
 
 
static int
check_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
{
  uint16_t size = ntohs (fb->header.size);
  uint16_t bsize = size - sizeof(*fb);
 
  (void) cls;
  if (0 == bsize)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (bsize + ntohs (fb->frag_off) > ntohs (fb->msg_size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (ntohs (fb->frag_off) >= ntohs (fb->msg_size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_YES;
}
 
 
static void
destroy_ack_cummulator (void *cls)
{
  struct AcknowledgementCummulator *ac = cls;
 
  ac->task = NULL;
  GNUNET_assert (0 == ac->num_acks);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (ack_cummulators, &ac->target, ac));
  GNUNET_free (ac);
}
 
 
static void
transmit_cummulative_ack_cb (void *cls)
{
  struct Neighbour *n;
  struct VirtualLink *vl;
  struct AcknowledgementCummulator *ac = cls;
  char buf[sizeof(struct TransportReliabilityAckMessage)
           + ac->num_acks
           * sizeof(struct TransportCummulativeAckPayloadP)] GNUNET_ALIGN;
  struct TransportReliabilityAckMessage *ack =
    (struct TransportReliabilityAckMessage *) buf;
  struct TransportCummulativeAckPayloadP *ap;
 
  ac->task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending ACK with %u components to %s\n",
              ac->num_acks,
              GNUNET_i2s (&ac->target));
  GNUNET_assert (0 < ac->num_acks);
  ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK);
  ack->header.size =
    htons (sizeof(*ack)
           + ac->num_acks * sizeof(struct TransportCummulativeAckPayloadP));
  ack->ack_counter = htonl (ac->ack_counter += ac->num_acks);
  ap = (struct TransportCummulativeAckPayloadP *) &ack[1];
  for (unsigned int i = 0; i < ac->num_acks; i++)
  {
    ap[i].ack_uuid = ac->ack_uuids[i].ack_uuid;
    ap[i].ack_delay = GNUNET_TIME_relative_hton (
      GNUNET_TIME_absolute_get_duration (ac->ack_uuids[i].receive_time));
  }
  /*route_control_message_without_fc (
    &ac->target,
    &ack->header,
    RMO_DV_ALLOWED);*/
  vl = lookup_virtual_link (&ac->target);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    route_control_message_without_fc (
      vl,
      &ack->header,
      RMO_DV_ALLOWED);
  }
  else
  {
    /* Use route via neighbour */
    n = lookup_neighbour (&ac->target);
    if (NULL != n)
      route_via_neighbour (
        n,
        &ack->header,
        RMO_NONE);
  }
  ac->num_acks = 0;
  /* The deadline belonged to the batch we just sent.  #cummulative_ack()
     only ever lowers it (GNUNET_TIME_absolute_min), so leaving it behind
     means every later ACK is armed with GNUNET_SCHEDULER_add_at() on a time
     that has already passed: the task fires on the next scheduler pass and
     the batching this whole structure exists for is gone for good -- one
     ACK message per received message, for the rest of the process' life. */
  ac->min_transmission_time = GNUNET_TIME_UNIT_FOREVER_ABS;
  ac->task = GNUNET_SCHEDULER_add_delayed (ACK_CUMMULATOR_TIMEOUT,
                                           &destroy_ack_cummulator,
                                           ac);
}
 
 
static void
cummulative_ack (const struct GNUNET_PeerIdentity *pid,
                 const struct AcknowledgementUUIDP *ack_uuid,
                 struct GNUNET_TIME_Absolute max_delay)
{
  struct AcknowledgementCummulator *ac;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Scheduling ACK %s for transmission to %s\n",
              GNUNET_uuid2s (&ack_uuid->value),
              GNUNET_i2s (pid));
  ac = GNUNET_CONTAINER_multipeermap_get (ack_cummulators, pid);
  if (NULL == ac)
  {
    ac = GNUNET_new (struct AcknowledgementCummulator);
    ac->target = *pid;
    ac->min_transmission_time = max_delay;
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_put (
                     ack_cummulators,
                     &ac->target,
                     ac,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  else
  {
    if (MAX_CUMMULATIVE_ACKS == ac->num_acks)
    {
      /* Must run immediately, ack buffer full.  Cancel the pending task
         FIRST: #transmit_cummulative_ack_cb() clears @e task without
         cancelling it, which would leave the old task armed with its
         handle lost. */
      GNUNET_SCHEDULER_cancel (ac->task);
      ac->task = NULL;
      transmit_cummulative_ack_cb (ac);
    }
    GNUNET_SCHEDULER_cancel (ac->task);
    ac->min_transmission_time =
      GNUNET_TIME_absolute_min (ac->min_transmission_time, max_delay);
  }
  GNUNET_assert (ac->num_acks < MAX_CUMMULATIVE_ACKS);
  ac->ack_uuids[ac->num_acks].receive_time = GNUNET_TIME_absolute_get ();
  ac->ack_uuids[ac->num_acks].ack_uuid = *ack_uuid;
  ac->num_acks++;
  ac->task = GNUNET_SCHEDULER_add_at (ac->min_transmission_time,
                                      &transmit_cummulative_ack_cb,
                                      ac);
}
 
 
struct FindByMessageUuidContext
{
  struct MessageUUIDP message_uuid;
 
  struct ReassemblyContext *rc;
};
 
 
static int
find_by_message_uuid (void *cls, uint32_t key, void *value)
{
  struct FindByMessageUuidContext *fc = cls;
  struct ReassemblyContext *rc = value;
 
  (void) key;
  if (0 == GNUNET_memcmp (&fc->message_uuid, &rc->msg_uuid))
  {
    fc->rc = rc;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}
 
 
static void
handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
{
  struct CommunicatorMessageContext *cmc = cls;
  struct VirtualLink *vl;
  struct ReassemblyContext *rc;
  const struct GNUNET_MessageHeader *msg;
  uint16_t msize;
  uint16_t fsize;
  uint16_t frag_off;
  char *target;
  struct GNUNET_TIME_Relative cdelay;
  struct FindByMessageUuidContext fc;
 
  vl = lookup_virtual_link (&cmc->im.sender);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    /* Entirely normal: fragments of a message that was already in flight
       keep arriving for a while after a link goes down, and a peer that has
       validated us may start sending before we have validated it.  This used
       to call #GNUNET_SERVICE_client_drop(), which disconnects the
       communicator *process* -- every queue it owns, hence every neighbour
       reachable through it, hence every CORE session.  On a peer with many
       neighbours a single ill-timed fragment therefore dropped all
       connections at once, and since the fragment comes from the network,
       any peer could cause it at will.  Drop the fragment, keep the
       communicator; see #demultiplex_with_cmc() for the same reasoning. */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No virtual link for %s to handle fragment\n",
                GNUNET_i2s (&cmc->im.sender));
    GNUNET_STATISTICS_update (GST_stats,
                              "# fragments dropped (virtual link down)",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  if (NULL == vl->reassembly_map)
  {
    vl->reassembly_map = GNUNET_CONTAINER_multihashmap32_create (8);
    vl->reassembly_heap =
      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
    vl->reassembly_timeout_task =
      GNUNET_SCHEDULER_add_delayed (REASSEMBLY_EXPIRATION,
                                    &reassembly_cleanup_task,
                                    vl);
  }
  msize = ntohs (fb->msg_size);
  fc.message_uuid = fb->msg_uuid;
  fc.rc = NULL;
  (void) GNUNET_CONTAINER_multihashmap32_get_multiple (vl->reassembly_map,
                                                       fb->msg_uuid.uuid,
                                                       &find_by_message_uuid,
                                                       &fc);
  fsize = ntohs (fb->header.size) - sizeof(*fb);
  if (NULL == (rc = fc.rc))
  {
    /* Bound the RAM a single sender can pin here: @e msg_size is chosen by
       the peer, not by us. */
    while (GNUNET_CONTAINER_multihashmap32_size (vl->reassembly_map) >=
           MAX_REASSEMBLY_CONTEXTS)
    {
      struct ReassemblyContext *drop;
 
      drop = GNUNET_CONTAINER_heap_peek (vl->reassembly_heap);
      GNUNET_assert (NULL != drop);
      GNUNET_STATISTICS_update (GST_stats,
                                "# Reassembly contexts dropped (limit reached)",
                                1,
                                GNUNET_NO);
      free_reassembly_context (drop);
    }
    rc = GNUNET_malloc (sizeof(*rc) + msize    /* reassembly payload buffer */
                        + (msize + 7) / 8 * sizeof(uint8_t) /* bitfield */);
    rc->msg_uuid = fb->msg_uuid;
    rc->virtual_link = vl;
    rc->msg_size = msize;
    rc->reassembly_timeout =
      GNUNET_TIME_relative_to_absolute (REASSEMBLY_EXPIRATION);
    rc->last_frag = GNUNET_TIME_absolute_get ();
    rc->hn = GNUNET_CONTAINER_heap_insert (vl->reassembly_heap,
                                           rc,
                                           rc->reassembly_timeout.abs_value_us);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multihashmap32_put (
                     vl->reassembly_map,
                     rc->msg_uuid.uuid,
                     rc,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
    target = (char *) &rc[1];
    rc->bitfield = (uint8_t *) (target + rc->msg_size);
    /* The bitfield loop below decrements @e msg_missing once per newly
       received byte, so this must always start at the full message size:
       initialising it to 0 for a single-fragment message made it
       underflow, and the message was then never delivered. */
    rc->msg_missing = rc->msg_size;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received fragment with size %u at offset %u/%u %u bytes missing from %s for NEW message %"
                PRIu64 "\n",
                fsize,
                ntohs (fb->frag_off),
                msize,
                rc->msg_missing,
                GNUNET_i2s (&cmc->im.sender),
                fb->msg_uuid.uuid);
  }
  else
  {
    target = (char *) &rc[1];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received fragment at offset %u/%u from %s for message %u\n",
                ntohs (fb->frag_off),
                msize,
                GNUNET_i2s (&cmc->im.sender),
                (unsigned int) fb->msg_uuid.uuid);
  }
  if (msize != rc->msg_size)
  {
    GNUNET_break (0);
    finish_cmc_handling (cmc);
    return;
  }
 
  /* reassemble */
  if (0 == fsize)
  {
    GNUNET_break (0);
    finish_cmc_handling (cmc);
    return;
  }
  frag_off = ntohs (fb->frag_off);
  if (frag_off + fsize > msize)
  {
    /* Fragment (plus fragment size) exceeds message size! */
    GNUNET_break_op (0);
    finish_cmc_handling (cmc);
    return;
  }
  memcpy (&target[frag_off], &fb[1], fsize);
  /* update bitfield and msg_missing */
  for (unsigned int i = frag_off; i < frag_off + fsize; i++)
  {
    if (0 == (rc->bitfield[i / 8] & (1 << (i % 8))))
    {
      rc->bitfield[i / 8] |= (1 << (i % 8));
      rc->msg_missing--;
    }
  }
 
  /* Compute cumulative ACK */
  cdelay = GNUNET_TIME_absolute_get_duration (rc->last_frag);
  cdelay = GNUNET_TIME_relative_multiply (cdelay, rc->msg_missing / fsize);
  if (0 == rc->msg_missing)
    cdelay = GNUNET_TIME_UNIT_ZERO;
  cummulative_ack (&cmc->im.sender,
                   &fb->ack_uuid,
                   GNUNET_TIME_relative_to_absolute (cdelay));
  rc->last_frag = GNUNET_TIME_absolute_get ();
  /* is reassembly complete? */
  if (0 != rc->msg_missing)
  {
    finish_cmc_handling (cmc);
    return;
  }
  /* reassembly is complete, verify result */
  msg = (const struct GNUNET_MessageHeader *) &rc[1];
  if (ntohs (msg->size) != rc->msg_size)
  {
    GNUNET_break (0);
    free_reassembly_context (rc);
    finish_cmc_handling (cmc);
    return;
  }
  /* successful reassembly */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Fragment reassembly complete for message %u\n",
              (unsigned int) fb->msg_uuid.uuid);
  /* FIXME: check that the resulting msg is NOT a
     DV Box or Reliability Box, as that is NOT allowed! */
  {
    uint16_t rsize = rc->msg_size;
    char rbuf[rsize] GNUNET_ALIGN;
 
    /* Copy the reassembled message out and release `rc' BEFORE
       demultiplexing: the inner message may tear down the virtual link,
       which frees every reassembly context of that link -- the old code
       then used and freed `rc' a second time afterwards. */
    memcpy (rbuf, msg, rsize);
    free_reassembly_context (rc);
    cmc->mh = (const struct GNUNET_MessageHeader *) rbuf;
    demultiplex_with_cmc (cmc);
  }
}
 
 
static int
check_reliability_box (void *cls,
                       const struct TransportReliabilityBoxMessage *rb)
{
  const struct GNUNET_MessageHeader *box =  (const struct
                                             GNUNET_MessageHeader *) &rb[1];
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "check_send_msg with size %u: inner msg type %u and size %u (%lu %lu)\n",
              ntohs (rb->header.size),
              ntohs (box->type),
              ntohs (box->size),
              sizeof (struct TransportReliabilityBoxMessage),
              sizeof (struct GNUNET_MessageHeader));
  GNUNET_MQ_check_boxed_message (rb);
  return GNUNET_YES;
}
 
 
static void
handle_reliability_box (void *cls,
                        const struct TransportReliabilityBoxMessage *rb)
{
  struct CommunicatorMessageContext *cmc = cls;
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &rb[1];
  struct GNUNET_TIME_Relative rtt;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received reliability box from %s with UUID %s of type %u\n",
              GNUNET_i2s (&cmc->im.sender),
              GNUNET_uuid2s (&rb->ack_uuid.value),
              (unsigned int) ntohs (inbox->type));
  rtt = GNUNET_TIME_UNIT_SECONDS; /* FIXME: should base this on "RTT", but we
                                     do not really have an RTT for the
                                   * incoming* queue (should we have
                                     the sender add it to the rb message?) */
  cummulative_ack (
    &cmc->im.sender,
    &rb->ack_uuid,
    (0 == ntohl (rb->ack_countdown))
    ? GNUNET_TIME_UNIT_ZERO_ABS
    : GNUNET_TIME_relative_to_absolute (
      GNUNET_TIME_relative_divide (rtt, 8 /* FIXME: magic constant */)));
  /* continue with inner message */
  /* FIXME: check that inbox is NOT a DV Box, fragment or another
     reliability box (not allowed!) */
  cmc->mh = inbox;
  demultiplex_with_cmc (cmc);
}
 
 
static void
update_pd_age (struct PerformanceData *pd, unsigned int age)
{
  unsigned int sage;
 
  if (age == pd->last_age)
    return; /* nothing to do */
  sage = GNUNET_MAX (pd->last_age, age - 2 * GOODPUT_AGING_SLOTS);
  for (unsigned int i = sage; i <= age - GOODPUT_AGING_SLOTS; i++)
  {
    struct TransmissionHistoryEntry *the = &pd->the[i % GOODPUT_AGING_SLOTS];
 
    the->bytes_sent = 0;
    the->bytes_received = 0;
  }
  pd->last_age = age;
}
 
 
static void
update_performance_data (struct PerformanceData *pd,
                         struct GNUNET_TIME_Relative rtt,
                         uint16_t bytes_transmitted_ok)
{
  uint64_t nval = rtt.rel_value_us;
  uint64_t oval = pd->aged_rtt.rel_value_us;
  unsigned int age = get_age ();
  struct TransmissionHistoryEntry *the = &pd->the[age % GOODPUT_AGING_SLOTS];
 
  if (oval == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
    pd->aged_rtt = rtt;
  else
    pd->aged_rtt.rel_value_us = (nval + 7 * oval) / 8;
  update_pd_age (pd, age);
  the->bytes_received += bytes_transmitted_ok;
}
 
 
static void
update_queue_performance (struct Queue *q,
                          struct GNUNET_TIME_Relative rtt,
                          uint16_t bytes_transmitted_ok)
{
  update_performance_data (&q->pd, rtt, bytes_transmitted_ok);
}
 
 
static void
update_dvh_performance (struct DistanceVectorHop *dvh,
                        struct GNUNET_TIME_Relative rtt,
                        uint16_t bytes_transmitted_ok)
{
  update_performance_data (&dvh->pd, rtt, bytes_transmitted_ok);
}
 
 
static void
completed_pending_message (struct PendingMessage *pm)
{
  struct PendingMessage *pos;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Complete transmission of message %" PRIu64 " %u\n",
              pm->logging_uuid,
              pm->pmt);
  switch (pm->pmt)
  {
  case PMT_CORE:
  case PMT_RELIABILITY_BOX:
    /* Full message sent, we are done */
    client_send_response (pm);
    return;
 
  case PMT_FRAGMENT_BOX:
    /* Fragment sent over reliable channel */
    pos = pm->frag_parent;
    GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm);
    free_pending_message (pm);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "pos frag_off %lu pos bytes_msg %lu pmt %u parent %u\n",
                (unsigned long) pos->frag_off,
                (unsigned long) pos->bytes_msg,
                pos->pmt,
                NULL == pos->frag_parent ? 1 : 0);
    /* check if subtree is done */
    while ((NULL == pos->head_frag) && (pos->frag_off == (pos->bytes_msg
                                                          - sizeof(struct
                                                                   TransportFragmentBoxMessage)))
           &&
           (NULL != pos->frag_parent))
    {
      pm = pos;
      pos = pm->frag_parent;
      if ((NULL == pos) && (PMT_DV_BOX == pm->pmt))
      {
        client_send_response (pm);
        return;
      }
      else if (PMT_DV_BOX == pm->pmt)
      {
        client_send_response (pos);
        return;
      }
      GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm);
      free_pending_message (pm);
    }
 
    /* Was this the last applicable fragment?
 
       NOTE: @a pos may be a DV box here, and then it is NOT the message the
       client is waiting for -- its @e frag_parent is, and that parent's
       @e bpm points at @a pos.  Answering the client directly (and thereby
       releasing @a pos through #free_pending_message()) left @e bpm of a
       message that is still queued pointing at freed memory, which
       #transmit_on_queue() reads and may free a second time.  Hand it to
       ourselves instead: the #PMT_DV_BOX case below clears @e bpm and
       answers for the parent, and for every other @e pmt it does exactly
       what the direct call did. */
    if ((NULL == pos->head_frag) && (NULL == pos->frag_parent || PMT_DV_BOX ==
                                     pos->pmt) &&
        (pos->frag_off == pos->bytes_msg))
      completed_pending_message (pos);
    return;
 
  case PMT_DV_BOX:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Completed transmission of message %" PRIu64 " (DV Box)\n",
                pm->logging_uuid);
    if (NULL != pm->frag_parent)
    {
      pos = pm->frag_parent;
      free_pending_message (pm);
      pos->bpm = NULL;
      client_send_response (pos);
    }
    else
      client_send_response (pm);
    return;
  }
}
 
 
static void
handle_acknowledged (struct PendingAcknowledgement *pa,
                     struct GNUNET_TIME_Relative ack_delay)
{
  struct GNUNET_TIME_Relative delay;
  struct PendingMessage *pm = pa->pm;
 
  delay = GNUNET_TIME_absolute_get_duration (pa->transmission_time);
  delay = GNUNET_TIME_relative_subtract (delay, ack_delay);
  if (NULL != pa->queue && 1 == pa->num_send)
    update_queue_performance (pa->queue, delay, pa->message_size);
  if (NULL != pa->dvh && 1 == pa->num_send)
    update_dvh_performance (pa->dvh, delay, pa->message_size);
  /* Retire @a pa BEFORE handing its message on.  completed_pending_message()
     ends in free_pending_message() for anything it finishes, and that now
     releases every acknowledgement still attached to the message -- this one
     included.  Freeing it afterwards is a double free, and it aborts on the
     GNUNET_assert() over multiuuidmap_remove() in
     free_pending_acknowledgement(), the map entry having gone with the first
     release.  Nothing below needs @a pa, only its message. */
  free_pending_acknowledgement (pa);
  if (NULL != pm)
    completed_pending_message (pm);
}
 
 
static int
check_reliability_ack (void *cls,
                       const struct TransportReliabilityAckMessage *ra)
{
  unsigned int n_acks;
 
  (void) cls;
  n_acks = (ntohs (ra->header.size) - sizeof(*ra))
           / sizeof(struct TransportCummulativeAckPayloadP);
  if (0 == n_acks)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((ntohs (ra->header.size) - sizeof(*ra)) !=
      n_acks * sizeof(struct TransportCummulativeAckPayloadP))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
handle_reliability_ack (void *cls,
                        const struct TransportReliabilityAckMessage *ra)
{
  struct CommunicatorMessageContext *cmc = cls;
  const struct TransportCummulativeAckPayloadP *ack;
  unsigned int n_acks;
  uint32_t ack_counter;
 
  n_acks = (ntohs (ra->header.size) - sizeof(*ra))
           / sizeof(struct TransportCummulativeAckPayloadP);
  ack = (const struct TransportCummulativeAckPayloadP *) &ra[1];
  for (unsigned int i = 0; i < n_acks; i++)
  {
    struct PendingAcknowledgement *pa =
      GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value);
    if (NULL == pa)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Received ACK from %s with UUID %s which is unknown to us!\n",
                  GNUNET_i2s (&cmc->im.sender),
                  GNUNET_uuid2s (&ack[i].ack_uuid.value));
      GNUNET_STATISTICS_update (
        GST_stats,
        "# FRAGMENT_ACKS dropped, no matching pending message",
        1,
        GNUNET_NO);
      continue;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received ACK from %s with UUID %s\n",
                GNUNET_i2s (&cmc->im.sender),
                GNUNET_uuid2s (&ack[i].ack_uuid.value));
    handle_acknowledged (pa, GNUNET_TIME_relative_ntoh (ack[i].ack_delay));
  }
 
  ack_counter = ntohl (ra->ack_counter);
  (void) ack_counter;  /* silence compiler warning for now */
  // FIXME-OPTIMIZE: track ACK losses based on ack_counter somewhere!
  // (DV and/or Neighbour?)
  finish_cmc_handling (cmc);
}
 
 
static int
check_backchannel_encapsulation (
  void *cls,
  const struct TransportBackchannelEncapsulationMessage *be)
{
  uint16_t size = ntohs (be->header.size) - sizeof(*be);
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &be[1];
  const char *is;
  uint16_t isize;
 
  (void) cls;
  /* MUST bound the buffer before reading @a inbox: the size check below
     dereferences it, and a message consisting of nothing but the header
     leaves no bytes to read. */
  if (size <= sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (ntohs (inbox->size) >= size)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  isize = ntohs (inbox->size);
  is = ((const char *) inbox) + isize;
  size -= isize;
  if ('\0' != is[size - 1])
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_YES;
}
 
 
static void
handle_backchannel_encapsulation (
  void *cls,
  const struct TransportBackchannelEncapsulationMessage *be)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct CommunicatorMessageContext *cmc = cls;
  struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *cbi;
  struct GNUNET_MQ_Envelope *env;
  struct TransportClient *tc;
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &be[1];
  uint16_t isize = ntohs (inbox->size);
  const char *target_communicator = ((const char *) inbox) + isize;
  char *sender;
  char *self;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  GNUNET_asprintf (&sender,
                   "%s",
                   GNUNET_i2s (&cmc->im.sender));
  GNUNET_asprintf (&self,
                   "%s",
                   GNUNET_i2s (my_identity));
 
  /* Find client providing this communicator */
  for (tc = clients_head; NULL != tc; tc = tc->next)
    if ((CT_COMMUNICATOR == tc->type) &&
        (NULL != tc->details.communicator.address_prefix) &&
        (0 ==
         strcmp (tc->details.communicator.address_prefix, target_communicator)))
      break;
  if (NULL == tc)
  {
    char *stastr;
 
    GNUNET_asprintf (
      &stastr,
      "# Backchannel message dropped: target communicator `%s' unknown",
      target_communicator);
    GNUNET_STATISTICS_update (GST_stats, stastr, 1, GNUNET_NO);
    GNUNET_free (stastr);
    GNUNET_free (sender);
    GNUNET_free (self);
    finish_cmc_handling (cmc);
    return;
  }
  /* Finally, deliver backchannel message to communicator */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Delivering backchannel message from %s to %s of type %u to %s\n",
              sender,
              self,
              ntohs (inbox->type),
              target_communicator);
  env = GNUNET_MQ_msg_extra (
    cbi,
    isize,
    GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING);
  cbi->pid = cmc->im.sender;
  memcpy (&cbi[1], inbox, isize);
  GNUNET_MQ_send (tc->mq, env);
  GNUNET_free (sender);
  GNUNET_free (self);
  finish_cmc_handling (cmc);
}
 
 
static void
path_cleanup_cb (void *cls)
{
  struct DistanceVector *dv = cls;
  struct DistanceVectorHop *pos;
  struct GNUNET_TIME_Absolute next;
 
  dv->timeout_task = NULL;
  /* @e dv_head is NOT sorted by @e timeout: learn_dv_path() inserts a new
     hop at the head, and moves a rediscovered one back to the head, so the
     list runs newest (i.e. latest deadline) first.  Stopping at the first
     live entry therefore inspected exactly the youngest hop and re-armed
     for *its* deadline, which is the last one of the whole set: expired
     hops behind it were never collected, and check_vl_transmission() kept
     skipping them one by one for as long as the route lived.  Sweep all of
     them and come back for the earliest survivor. */
  next = GNUNET_TIME_UNIT_FOREVER_ABS;
  pos = dv->dv_head;
  while (NULL != pos)
  {
    struct DistanceVectorHop *next_pos = pos->next_dv;
 
    GNUNET_assert (dv == pos->dv);
    if (0 == GNUNET_TIME_absolute_get_remaining (pos->timeout).rel_value_us)
      free_distance_vector_hop (pos);
    else
      next = GNUNET_TIME_absolute_min (next, pos->timeout);
    pos = next_pos;
  }
  if (NULL == dv->dv_head)
  {
    free_dv_route (dv);
    return;
  }
  dv->timeout_task =
    GNUNET_SCHEDULER_add_at (next, &path_cleanup_cb, dv);
}
 
 
static void
send_msg_from_cache (struct VirtualLink *vl)
{
 
  const struct GNUNET_PeerIdentity target = vl->target;
 
 
  if ((GNUNET_YES == is_ring_buffer_full) || (0 < ring_buffer_head))
  {
    struct RingBufferEntry *ring_buffer_copy[RING_BUFFER_SIZE];
    unsigned int tail = GNUNET_YES == is_ring_buffer_full ? ring_buffer_head :
                        0;
    unsigned int head = GNUNET_YES == is_ring_buffer_full ? RING_BUFFER_SIZE :
                        ring_buffer_head;
    struct GNUNET_TRANSPORT_IncomingMessage im;
    struct CommunicatorMessageContext *cmc;
    struct RingBufferEntry *rbe;
    struct GNUNET_MessageHeader *mh;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending from ring buffer, which has %u items\n",
                head);
 
    ring_buffer_head = 0;
    for (unsigned int i = 0; i < head; i++)
    {
      rbe = ring_buffer[(i + tail) % RING_BUFFER_SIZE];
      cmc = rbe->cmc;
      mh = rbe->mh;
 
      im = cmc->im;
      // mh = cmc->mh;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending message of type %u to ring buffer target %s using vl target %s index %u\n",
                  mh->type,
                  GNUNET_i2s (&im.sender),
                  GNUNET_i2s2 (&target),
                  (i + tail) % RING_BUFFER_SIZE);
      if (0 == GNUNET_memcmp (&target, &im.sender))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Finish handling message of type %u and size %u\n",
                    (unsigned int) ntohs (mh->type),
                    (unsigned int) ntohs (mh->size));
        finish_handling_raw_message (vl, mh, cmc, GNUNET_NO);
        GNUNET_free (mh);
        GNUNET_free (rbe->cmc);
        GNUNET_free (rbe);
      }
      else
      {
        ring_buffer_copy[ring_buffer_head] = rbe;
        ring_buffer_head++;
      }
    }
 
    if ((GNUNET_YES == is_ring_buffer_full) &&
        (RING_BUFFER_SIZE > ring_buffer_head))
    {
      is_ring_buffer_full = GNUNET_NO;
    }
 
    for (unsigned int i = 0; i < ring_buffer_head; i++)
    {
      ring_buffer[i] = ring_buffer_copy[i];
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "ring_buffer[i]->mh->type for i %u %u\n",
                  i,
                  ring_buffer[i]->mh->type);
    }
    /* MUST clear the consumed slots, we freed those entries above */
    for (unsigned int i = ring_buffer_head; i < RING_BUFFER_SIZE; i++)
      ring_buffer[i] = NULL;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u items still in ring buffer\n",
                ring_buffer_head);
    /* If we consumed nothing, compaction rewrote the buffer in place and
       left the write index one past the end.  #handle_raw_message() would
       then read ring_buffer[RING_BUFFER_SIZE] and free whatever that is.
       The buffer is still full, and compaction moved the oldest entry to
       slot 0, so that is where the next write belongs. */
    if (RING_BUFFER_SIZE == ring_buffer_head)
      ring_buffer_head = 0;
  }
 
  if ((GNUNET_YES == is_ring_buffer_dv_full) || (0 < ring_buffer_dv_head))
  {
    struct PendingMessage *ring_buffer_dv_copy[RING_BUFFER_SIZE];
    struct PendingMessage *pm;
    unsigned int tail = GNUNET_YES == is_ring_buffer_dv_full ?
                        ring_buffer_dv_head :
                        0;
    unsigned int head = GNUNET_YES == is_ring_buffer_dv_full ?
                        RING_BUFFER_SIZE :
                        ring_buffer_dv_head;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending from ring buffer dv, which has %u items\n",
                head);
 
    ring_buffer_dv_head = 0;
    for (unsigned int i = 0; i < head; i++)
    {
      pm = ring_buffer_dv[(i + tail) % RING_BUFFER_SIZE];
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending to ring buffer target %s using vl target %s\n",
                  GNUNET_i2s (&pm->target),
                  GNUNET_i2s2 (&target));
      if (0 == GNUNET_memcmp (&target, &pm->target))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Adding PendingMessage to vl, checking transmission.\n");
        pm->vl = vl;
        GNUNET_CONTAINER_MDLL_insert (vl,
                                      vl->pending_msg_head,
                                      vl->pending_msg_tail,
                                      pm);
 
        check_vl_transmission (vl);
      }
      else
      {
        ring_buffer_dv_copy[ring_buffer_dv_head] = pm;
        ring_buffer_dv_head++;
      }
    }
 
    if (is_ring_buffer_dv_full && (RING_BUFFER_SIZE > ring_buffer_dv_head))
    {
      is_ring_buffer_dv_full = GNUNET_NO;
    }
 
    for (unsigned int i = 0; i < ring_buffer_dv_head; i++)
      ring_buffer_dv[i] = ring_buffer_dv_copy[i];
    /* MUST clear the consumed slots: entries we handed to a VirtualLink are
       now owned by that link, and #forward_dv_box() would GNUNET_free() them
       again once the ring buffer wraps around. */
    for (unsigned int i = ring_buffer_dv_head; i < RING_BUFFER_SIZE; i++)
      ring_buffer_dv[i] = NULL;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u items still in ring buffer dv.\n",
                ring_buffer_dv_head);
    /* Same one-past-the-end hazard as above: #forward_dv_box() reads
       ring_buffer_dv[ring_buffer_dv_head] and GNUNET_free()s it. */
    if (RING_BUFFER_SIZE == ring_buffer_dv_head)
      ring_buffer_dv_head = 0;
  }
}
 
 
static void
activate_core_visible_dv_path (struct DistanceVectorHop *hop)
{
  struct DistanceVector *dv = hop->dv;
  struct VirtualLink *vl;
 
  vl = lookup_virtual_link (&dv->target);
  if (NULL == vl)
  {
 
    vl = GNUNET_new (struct VirtualLink);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Creating new virtual link %p to %s using DV!\n",
                vl,
                GNUNET_i2s (&dv->target));
    vl->burst_addr = NULL;
    vl->confirmed = GNUNET_YES;
    vl->message_uuid_ctr =
      GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    vl->target = dv->target;
    vl->core_recv_window = RECV_WINDOW_SIZE;
    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
    /* What the peer will grant us in its very first FLOW_CONTROL anyway
       (@e incoming_fc_window_size plus what we have sent, i.e. nothing).
       Starting at zero instead means a link that is up, validated and
       working carries nothing at all until an FC round trip completes --
       and if the peer cannot answer, not ever. */
    vl->outbound_fc_window_size = DEFAULT_WINDOW_SIZE;
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_put (
                    links,
                    &vl->target,
                    vl,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    vl->dv = dv;
    dv->vl = vl;
    vl->visibility_task =
      GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl);
    consider_sending_fc (vl);
    /* We lacked a confirmed connection to the target
       before, so tell CORE about it (finally!) */
    cores_send_connect_info (&dv->target);
    send_msg_from_cache (vl);
  }
  else
  {
    /* Link was already up, remember dv is also now available and we are done */
    vl->dv = dv;
    dv->vl = vl;
    if (GNUNET_NO == vl->confirmed)
    {
      vl->confirmed = GNUNET_YES;
      vl->visibility_task =
        GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl);
      consider_sending_fc (vl);
      /* We lacked a confirmed connection to the target
         before, so tell CORE about it (finally!) */
      cores_send_connect_info (&dv->target);
      send_msg_from_cache (vl);
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Virtual link to %s could now also use DV!\n",
                  GNUNET_i2s (&dv->target));
  }
}
 
 
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)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct DistanceVectorHop *hop;
  struct DistanceVector *dv;
  struct Neighbour *next_hop;
  unsigned int shorter_distance;
 
  if (path_len < 3)
  {
    /* what a boring path! not allowed! */
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  GNUNET_assert (0 == GNUNET_memcmp (my_identity, &path[0]));
  next_hop = lookup_neighbour (&path[1]);
  if (NULL == next_hop)
  {
    /* next hop must be a neighbour, otherwise this whole thing is useless! */
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  for (unsigned int i = 2; i < path_len; i++)
  {
    struct Neighbour *n = lookup_neighbour (&path[i]);
    struct GNUNET_TIME_Absolute q_timeout;
 
    if (NULL != n)
    {
      q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
      for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
        q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "remaining %lu to %s\n",
                  (unsigned long) GNUNET_TIME_absolute_get_remaining (q_timeout)
                  .rel_value_us,
                  GNUNET_i2s (&n->pid));
      if (0 != GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
      {
        /* Useless path: we have a direct active connection to some hop
           in the middle of the path, so this one is not even
           terribly useful for redundancy */
        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                    "Path of %u hops useless: directly link to hop %u (%s)\n",
                    path_len,
                    i,
                    GNUNET_i2s (&path[i]));
        GNUNET_STATISTICS_update (GST_stats,
                                  "# Useless DV path ignored: hop is neighbour",
                                  1,
                                  GNUNET_NO);
        return GNUNET_SYSERR;
      }
    }
  }
  dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &path[path_len - 1]);
  if (NULL == dv)
  {
    dv = GNUNET_new (struct DistanceVector);
    dv->target = path[path_len - 1];
    dv->timeout_task = GNUNET_SCHEDULER_add_delayed (DV_PATH_VALIDITY_TIMEOUT,
                                                     &path_cleanup_cb,
                                                     dv);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (
                     dv_routes,
                     &dv->target,
                     dv,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  /* Check if we have this path already! */
  shorter_distance = 0;
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    if (pos->distance < path_len - 3)
      shorter_distance++;
    /* Note that the distances in 'pos' excludes us (path[0]),
       the next_hop (path[1]) and the target so we need to subtract three
       and check next_hop explicitly */
    if ((pos->distance == path_len - 3) && (pos->next_hop == next_hop))
    {
      int match = GNUNET_YES;
 
      for (unsigned int i = 0; i < pos->distance; i++)
      {
        if (0 != GNUNET_memcmp (&pos->path[i], &path[i + 2]))
        {
          match = GNUNET_NO;
          break;
        }
      }
      if (GNUNET_YES == match)
      {
        struct GNUNET_TIME_Relative last_timeout;
 
        /* Re-discovered known path, update timeout */
        GNUNET_STATISTICS_update (GST_stats,
                                  "# Known DV path refreshed",
                                  1,
                                  GNUNET_NO);
        last_timeout = GNUNET_TIME_absolute_get_remaining (pos->timeout);
        pos->timeout =
          GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
        pos->path_valid_until =
          GNUNET_TIME_absolute_max (pos->path_valid_until, path_valid_until);
        GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, pos);
        GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, pos);
        if (0 <
            GNUNET_TIME_absolute_get_remaining (path_valid_until).rel_value_us)
          activate_core_visible_dv_path (pos);
        if (last_timeout.rel_value_us <
            GNUNET_TIME_relative_subtract (DV_PATH_VALIDITY_TIMEOUT,
                                           DV_PATH_DISCOVERY_FREQUENCY)
            .rel_value_us)
        {
          /* Some peer send DV learn messages too often, we are learning
             the same path faster than it would be useful; do not forward! */
          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                      "Rediscovered path too quickly, not forwarding further\n")
          ;
          return GNUNET_NO;
        }
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Refreshed known path to %s valid until %s, forwarding further\n",
                    GNUNET_i2s (&dv->target),
                    GNUNET_STRINGS_absolute_time_to_string (
                      pos->path_valid_until));
        return GNUNET_YES;
      }
    }
  }
  /* Count how many shorter paths we have (incl. direct
     neighbours) before simply giving up on this one! */
  if (shorter_distance >= MAX_DV_PATHS_TO_TARGET)
  {
    /* We have a shorter path already! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Have many shorter DV paths %s, not forwarding further\n",
                GNUNET_i2s (&dv->target));
    return GNUNET_NO;
  }
  /* create new DV path entry */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Discovered new DV path to %s valid until %s\n",
              GNUNET_i2s (&dv->target),
              GNUNET_STRINGS_absolute_time_to_string (path_valid_until));
  hop = GNUNET_malloc (sizeof(struct DistanceVectorHop)
                       + sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
  hop->next_hop = next_hop;
  hop->dv = dv;
  hop->path = (const struct GNUNET_PeerIdentity *) &hop[1];
  memcpy (&hop[1],
          &path[2],
          sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
  hop->timeout = GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
  hop->path_valid_until = path_valid_until;
  hop->distance = path_len - 3;
  hop->pd.aged_rtt = network_latency;
  GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, hop);
  GNUNET_CONTAINER_MDLL_insert (neighbour,
                                next_hop->dv_head,
                                next_hop->dv_tail,
                                hop);
  if (0 < GNUNET_TIME_absolute_get_remaining (path_valid_until).rel_value_us)
    activate_core_visible_dv_path (hop);
  return GNUNET_YES;
}
 
 
static int
check_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
{
  const struct GNUNET_PeerIdentity *my_identity;
  uint16_t size = ntohs (dvl->header.size);
  uint16_t num_hops = ntohs (dvl->num_hops);
  const struct DVPathEntryP *hops = (const struct DVPathEntryP *) &dvl[1];
 
  (void) cls;
  if (size != sizeof(*dvl) + num_hops * sizeof(struct DVPathEntryP))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (num_hops > MAX_DV_HOPS_ALLOWED)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  for (unsigned int i = 0; i < num_hops; i++)
  {
    if (0 == GNUNET_memcmp (&dvl->initiator, &hops[i].hop))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if (0 == GNUNET_memcmp (my_identity, &hops[i].hop))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
  }
  return GNUNET_YES;
}
 
 
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)
{
  struct DVPathEntryP *dhops;
  size_t fwd_size = sizeof(struct TransportDVLearnMessage)
                    + (nhops + 1) * sizeof(struct DVPathEntryP);
  /* Signing is synchronous and the routing calls below copy the message,
     so this never outlives the frame.  Keeping it on the stack matters:
     a hub forwards a DV learn to every eligible neighbour, so this is one
     of the hottest allocation sites in the service.  Size it by the hop
     limit rather than by @a nhops -- @a nhops is only asserted to be below
     that limit further down, and a VLA is sized before we get there. */
  char fwd_buf[sizeof(struct TransportDVLearnMessage)
               + (MAX_DV_HOPS_ALLOWED + 1)
               * sizeof(struct DVPathEntryP)] GNUNET_ALIGN;
  struct TransportDVLearnMessage *fwd
    = (struct TransportDVLearnMessage *) fwd_buf;
  struct GNUNET_TIME_Relative nnd;
  const struct GNUNET_PeerIdentity *my_identity;
  struct VirtualLink *vl;
  struct Neighbour *n;
 
  GNUNET_assert (nhops < MAX_DV_HOPS_ALLOWED);
  memset (fwd_buf, 0, fwd_size);
 
  /* compute message for forwarding */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding DV learn message originating from %s to %s\n",
              GNUNET_i2s (&msg->initiator),
              GNUNET_i2s2 (next_hop));
  GNUNET_assert (nhops < MAX_DV_HOPS_ALLOWED);
  fwd->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
  fwd->header.size = htons (sizeof(struct TransportDVLearnMessage)
                            + (nhops + 1) * sizeof(struct DVPathEntryP));
  fwd->num_hops = htons (nhops + 1);
  fwd->bidirectional = htons (bi_history);
  nnd = GNUNET_TIME_relative_add (GNUNET_TIME_absolute_get_duration (in_time),
                                  GNUNET_TIME_relative_ntoh (
                                    msg->non_network_delay));
  fwd->non_network_delay = GNUNET_TIME_relative_hton (nnd);
  fwd->init_sig = msg->init_sig;
  fwd->initiator = msg->initiator;
  fwd->challenge = msg->challenge;
  fwd->monotonic_time = msg->monotonic_time;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  dhops = (struct DVPathEntryP *) &fwd[1];
  GNUNET_memcpy (dhops, hops, sizeof(struct DVPathEntryP) * nhops);
  dhops[nhops].hop = *my_identity;
  {
    struct DvHopPS dhp = {
      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
      .purpose.size = htonl (sizeof(dhp)),
      .pred = (0 == nhops) ? msg->initiator : dhops[nhops - 1].hop,
      .succ = *next_hop,
      .challenge = msg->challenge
    };
 
    if (GNUNET_OK != sign_by_my_identity (&dhp.purpose,
                                          &dhops[nhops].hop_sig))
      return;   /* nobody would accept the path without our hop signature */
  }
  vl = lookup_virtual_link (next_hop);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    route_control_message_without_fc (vl,
                                      &fwd->header,
                                      RMO_UNCONFIRMED_ALLOWED);
    return;
  }
  /* Use route via neighbour */
  n = lookup_neighbour (next_hop);
  if (NULL != n)
    route_via_neighbour (n,
                         &fwd->header,
                         RMO_UNCONFIRMED_ALLOWED);
}
 
 
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)
{
  struct DvInitPS ip = { .purpose.purpose = htonl (
                           GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
                         .purpose.size = htonl (sizeof(ip)),
                         .monotonic_time = sender_monotonic_time,
                         .challenge = *challenge };
 
  if (
    GNUNET_OK !=
    GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR,
                                &ip,
                                init_sig,
                                &init->public_key))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
struct NeighbourSelectionContext
{
  const struct TransportDVLearnMessage *dvl;
 
  const struct DVPathEntryP *hops;
 
  struct GNUNET_TIME_Absolute in_time;
 
  uint32_t selections[MAX_DV_DISCOVERY_SELECTION];
 
  unsigned int num_eligible;
 
  unsigned int num_selections;
 
  uint16_t nhops;
 
  uint16_t bi_history;
};
 
 
static int
dv_neighbour_selection (void *cls,
                        const struct GNUNET_PeerIdentity *pid,
                        void *value)
{
  struct NeighbourSelectionContext *nsc = cls;
 
  (void) value;
  if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
    return GNUNET_YES; /* skip initiator */
  for (unsigned int i = 0; i < nsc->nhops; i++)
    if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
      return GNUNET_YES;
  /* skip peers on path */
  nsc->num_eligible++;
  return GNUNET_YES;
}
 
 
static int
dv_neighbour_transmission (void *cls,
                           const struct GNUNET_PeerIdentity *pid,
                           void *value)
{
  struct NeighbourSelectionContext *nsc = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "transmission %s\n",
              GNUNET_i2s (pid));
  (void) value;
  if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
    return GNUNET_YES; /* skip initiator */
  for (unsigned int i = 0; i < nsc->nhops; i++)
    if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
      return GNUNET_YES;
  /* skip peers on path */
  for (unsigned int i = 0; i < nsc->num_selections; i++)
  {
    if (nsc->selections[i] == nsc->num_eligible)
    {
      forward_dv_learn (pid,
                        nsc->dvl,
                        nsc->bi_history,
                        nsc->nhops,
                        nsc->hops,
                        nsc->in_time);
      break;
    }
  }
  nsc->num_eligible++;
  return GNUNET_YES;
}
 
 
static unsigned int
calculate_fork_degree (unsigned int hops_taken,
                       unsigned int neighbour_count,
                       unsigned int eligible_count)
{
  double target_total = 50.0; /* FIXME: use LOG(NSE)? */
  double eligible_ratio =
    ((double) eligible_count) / ((double) neighbour_count);
  double boost_factor = eligible_ratio * eligible_ratio;
  unsigned int rnd;
  double left;
 
  if (hops_taken >= 64)
  {
    GNUNET_break (0);
    return 0;   /* precaution given bitshift below */
  }
  for (unsigned int i = 1; i < hops_taken; i++)
  {
    /* For each hop, subtract the expected number of targets
       reached at distance d (so what remains divided by 2^d) */
    target_total -= (target_total * boost_factor / (1LLU << i));
  }
  {
    double degree = target_total * boost_factor / (1LLU << hops_taken);
 
    rnd = (unsigned int) floor (degree);
    /* round up or down probabilistically depending on how close we were
       when floor()ing to rnd.  NOTE: this must be the fractional part of
       @e degree; using `target_total - rnd' here made the condition below
       true essentially always, so we always rounded up. */
    left = degree - (double) rnd;
  }
  if (UINT32_MAX * left >
      GNUNET_CRYPTO_random_u64 (UINT32_MAX))
    rnd++; /* round up */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding DV learn message of %u hops %u(/%u/%u) times\n",
              hops_taken,
              rnd,
              eligible_count,
              neighbour_count);
  return rnd;
}
 
 
static void
neighbour_store_dvmono_cb (void *cls, int success)
{
  struct Neighbour *n = cls;
 
  n->sc = NULL;
  if (GNUNET_YES != success)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store other peer's monotonic time in peerstore!\n");
}
 
 
static struct GNUNET_TIME_Relative
get_network_latency (const struct TransportDVLearnMessage *dvl)
{
  struct GNUNET_TIME_Relative host_latency_sum;
  struct GNUNET_TIME_Relative latency;
  struct GNUNET_TIME_Relative network_latency;
  uint16_t nhops = ntohs (dvl->num_hops);;
 
  /* We initiated this, learn the forward path! */
  host_latency_sum = GNUNET_TIME_relative_ntoh (dvl->non_network_delay);
 
  // Need also something to lookup initiation time
  // to compute RTT! -> add RTT argument here?
  latency = GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh (
                                                 dvl->monotonic_time));
  /* @e non_network_delay is fully attacker-controlled, and our clock may
     simply be behind the initiator's: never assert on this. */
  if (latency.rel_value_us < host_latency_sum.rel_value_us)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV learn with implausible non-network delay",
                              1,
                              GNUNET_NO);
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
  // latency = GNUNET_TIME_UNIT_FOREVER_REL;   // FIXME: initialize properly
  // (based on dvl->challenge, we can identify time of origin!)
 
  network_latency = GNUNET_TIME_relative_subtract (latency, host_latency_sum);
  /* assumption: latency on all links is the same */
  network_latency = GNUNET_TIME_relative_divide (network_latency, nhops);
 
  return network_latency;
}
 
 
static void
handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
{
  struct CommunicatorMessageContext *cmc = cls;
  enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc;
  int bi_hop;
  uint16_t nhops;
  uint16_t bi_history;
  const struct DVPathEntryP *hops;
  int do_fwd;
  int did_initiator;
  struct GNUNET_TIME_Absolute in_time;
  struct Neighbour *n;
  const struct GNUNET_PeerIdentity *my_identity;
 
  nhops = ntohs (dvl->num_hops);  /* 0 = sender is initiator */
  bi_history = ntohs (dvl->bidirectional);
  hops = (const struct DVPathEntryP *) &dvl[1];
  if (0 == nhops)
  {
    /* sanity check */
    if (0 != GNUNET_memcmp (&dvl->initiator, &cmc->im.sender))
    {
      GNUNET_break (0);
      finish_cmc_handling (cmc);
      return;
    }
    /* A zero-hop message we supposedly initiated ourselves would make the
       "we are the initiator" branch below read hops[0] and write past the
       end of its `path[nhops + 1]' array. */
    if (0 == GNUNET_memcmp (&dvl->initiator, GNUNET_PILS_get_identity (pils)))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "handle dv learn message last hop %s\n",
                GNUNET_i2s (&hops[nhops - 1].hop));
    /* sanity check */
    if (0 != GNUNET_memcmp (&hops[nhops - 1].hop, &cmc->im.sender))
    {
      GNUNET_break (0);
      finish_cmc_handling (cmc);
      return;
    }
  }
 
  GNUNET_assert (CT_COMMUNICATOR == cmc->tc->type);
  cc = cmc->tc->details.communicator.cc;
  bi_hop = (GNUNET_TRANSPORT_CC_RELIABLE ==
            cc); // FIXME: add bi-directional flag to cc?
  in_time = GNUNET_TIME_absolute_get ();
 
  /* continue communicator here, everything else can happen asynchronous! */
  finish_cmc_handling (cmc);
 
  n = lookup_neighbour (&dvl->initiator);
  if (NULL != n)
  {
    if ((n->dv_monotime_available == GNUNET_YES) &&
        (GNUNET_TIME_absolute_ntoh (dvl->monotonic_time).abs_value_us <
         n->last_dv_learn_monotime.abs_value_us))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV learn from %s discarded due to time travel",
                  GNUNET_i2s (&dvl->initiator));
      GNUNET_STATISTICS_update (GST_stats,
                                "# DV learn discarded due to time travel",
                                1,
                                GNUNET_NO);
      return;
    }
    if (GNUNET_OK != validate_dv_initiator_signature (dvl->monotonic_time,
                                                      &dvl->initiator,
                                                      &dvl->challenge,
                                                      &dvl->init_sig))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV learn signature from %s invalid\n",
                  GNUNET_i2s (&dvl->initiator));
      GNUNET_break_op (0);
      return;
    }
    n->last_dv_learn_monotime = GNUNET_TIME_absolute_ntoh (dvl->monotonic_time);
    if (GNUNET_YES == n->dv_monotime_available)
    {
      if (NULL != n->sc)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "store cancel\n");
        GNUNET_PEERSTORE_store_cancel (n->sc);
      }
      n->sc =
        GNUNET_PEERSTORE_store (peerstore,
                                "transport",
                                &dvl->initiator,
                                GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
                                &dvl->monotonic_time,
                                sizeof(dvl->monotonic_time),
                                GNUNET_TIME_UNIT_FOREVER_ABS,
                                GNUNET_PEERSTORE_STOREOPTION_REPLACE,
                                &neighbour_store_dvmono_cb,
                                n);
    }
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  /* OPTIMIZE-FIXME: asynchronously (!) verify signatures!,
     If signature verification load too high, implement random drop strategy */
  for (unsigned int i = 0; i < nhops; i++)
  {
    struct DvHopPS dhp = { .purpose.purpose =
                             htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
                           .purpose.size = htonl (sizeof(dhp)),
                           .pred = (0 == i) ? dvl->initiator : hops[i - 1].hop,
                           .succ = (nhops == i + 1) ? *my_identity
                                   : hops[i + 1].hop,
                           .challenge = dvl->challenge };
 
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP,
                                    &dhp,
                                    &hops[i].hop_sig,
                                    &hops[i].hop.public_key))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV learn from %s signature of hop %u invalid\n",
                  GNUNET_i2s (&dvl->initiator),
                  i);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "signature of hop %s invalid\n",
                  GNUNET_i2s (&hops[i].hop));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "pred %s\n",
                  GNUNET_i2s (&dhp.pred));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "succ %s\n",
                  GNUNET_i2s (&dhp.succ));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "hash %s\n",
                  GNUNET_sh2s (&dhp.challenge.value));
      GNUNET_break_op (0);
      return;
    }
  }
  if (GNUNET_EXTRA_LOGGING > 0)
  {
    char *path;
 
    path = GNUNET_strdup (GNUNET_i2s (&dvl->initiator));
    for (unsigned int i = 0; i < nhops; i++)
    {
      char *tmp;
 
      GNUNET_asprintf (&tmp,
                       "%s%s%s",
                       path,
                       (bi_history & (1 << (nhops - i))) ? "<->" : "-->",
                       GNUNET_i2s (&hops[i].hop));
      GNUNET_free (path);
      path = tmp;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received DVInit via %s%s%s\n",
                path,
                bi_hop ? "<->" : "-->",
                GNUNET_i2s (my_identity));
    GNUNET_free (path);
  }
  do_fwd = GNUNET_YES;
  if (0 == GNUNET_memcmp (my_identity, &dvl->initiator))
  {
    struct GNUNET_PeerIdentity path[nhops + 1];
    struct GNUNET_TIME_Relative network_latency;
 
    /* We initiated this, learn the forward path! */
    path[0] = *my_identity;
    path[1] = hops[0].hop;
 
    network_latency = get_network_latency (dvl);
 
    for (unsigned int i = 2; i <= nhops; i++)
    {
      struct GNUNET_TIME_Relative ilat;
 
      /* assumption: linear latency increase per hop */
      ilat = GNUNET_TIME_relative_multiply (network_latency, i);
      path[i] = hops[i - 1].hop;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Learned path with %u hops to %s with latency %s\n",
                  i,
                  GNUNET_i2s (&path[i]),
                  GNUNET_STRINGS_relative_time_to_string (ilat, GNUNET_YES));
      learn_dv_path (path,
                     i + 1,
                     ilat,
                     GNUNET_TIME_relative_to_absolute (
                       ADDRESS_VALIDATION_LIFETIME));
    }
    /* as we initiated, do not forward again (would be circular!) */
    do_fwd = GNUNET_NO;
    return;
  }
  if (bi_hop)
  {
    /* last hop was bi-directional, we could learn something here! */
    struct GNUNET_PeerIdentity path[nhops + 2];
    struct GNUNET_TIME_Relative ilat;
    struct GNUNET_TIME_Relative network_latency;
 
    path[0] = *my_identity;
    path[1] = hops[nhops - 1].hop;   /* direct neighbour == predecessor! */
    for (unsigned int i = 0; i < nhops; i++)
    {
      int iret;
 
      if (0 == (bi_history & (1 << i)))
        break;     /* i-th hop not bi-directional, stop learning! */
      if (i == nhops - 1)
      {
        path[i + 2] = dvl->initiator;
      }
      else
      {
        path[i + 2] = hops[nhops - i - 2].hop;
      }
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Learned inverse path with %u hops to %s\n",
                  i + 2,
                  GNUNET_i2s (&path[i + 2]));
      network_latency = get_network_latency (dvl);
      ilat = GNUNET_TIME_relative_multiply (network_latency, i + 2);
      iret = learn_dv_path (path,
                            i + 3,
                            ilat,
                            GNUNET_TIME_relative_to_absolute (
                              ADDRESS_VALIDATION_LIFETIME));
      if (GNUNET_SYSERR == iret)
      {
        /* path invalid or too long to be interesting for US, thus should also
           not be interesting to our neighbours, cut path when forwarding to
           'i' hops, except of course for the one that goes back to the
           initiator */
        GNUNET_STATISTICS_update (GST_stats,
                                  "# DV learn not forwarded due invalidity of path",
                                  1,
                                  GNUNET_NO);
        do_fwd = GNUNET_NO;
        break;
      }
      if ((GNUNET_NO == iret) && (nhops == i + 1))
      {
        /* we have better paths, and this is the longest target,
           so there cannot be anything interesting later */
        GNUNET_STATISTICS_update (GST_stats,
                                  "# DV learn not forwarded, got better paths",
                                  1,
                                  GNUNET_NO);
        do_fwd = GNUNET_NO;
        break;
      }
    }
  }
  if (MAX_DV_HOPS_ALLOWED == nhops)
  {
    /* At limit, we're out of here! */
    return;
  }
 
  /* Forward to initiator, if path non-trivial and possible */
  bi_history = (bi_history << 1) | (bi_hop ? 1 : 0);
  did_initiator = GNUNET_NO;
  if ((1 <= nhops) &&
      (GNUNET_YES ==
       GNUNET_CONTAINER_multipeermap_contains (neighbours, &dvl->initiator)))
  {
    /* send back to origin! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending DVL back to initiator %s\n",
                GNUNET_i2s (&dvl->initiator));
    forward_dv_learn (&dvl->initiator, dvl, bi_history, nhops, hops, in_time);
    did_initiator = GNUNET_YES;
  }
  /* We forward under two conditions: either we still learned something
     ourselves (do_fwd), or the path was darn short and thus the initiator is
     likely to still be very interested in this (and we did NOT already
     send it back to the initiator) */
  if ((do_fwd) || ((nhops < MIN_DV_PATH_LENGTH_FOR_INITIATOR) &&
                   (GNUNET_NO == did_initiator)))
  {
    /* Pick random neighbours that are not yet on the path */
    struct NeighbourSelectionContext nsc;
    unsigned int n_cnt;
    unsigned int n_eligible;
 
    n_cnt = GNUNET_CONTAINER_multipeermap_size (neighbours);
    nsc.nhops = nhops;
    nsc.dvl = dvl;
    nsc.bi_history = bi_history;
    nsc.hops = hops;
    nsc.in_time = in_time;
    nsc.num_eligible = 0;
    GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                           &dv_neighbour_selection,
                                           &nsc);
    if (0 == nsc.num_eligible)
      return;   /* done here, cannot forward to anyone else */
    n_eligible = nsc.num_eligible;
    nsc.num_selections = calculate_fork_degree (nhops, n_cnt, n_eligible);
    nsc.num_selections =
      GNUNET_MIN (MAX_DV_DISCOVERY_SELECTION, nsc.num_selections);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Forwarding DVL to %u other peers\n",
                nsc.num_selections);
    /* #dv_neighbour_transmission() counts ELIGIBLE peers only, so the
       offsets must be drawn from that range -- drawing from the total
       number of neighbours made us silently forward to fewer peers than
       #calculate_fork_degree() asked for. */
    for (unsigned int i = 0; i < nsc.num_selections; i++)
      nsc.selections[i] =
        (nsc.num_selections == n_eligible)
        ? i   /* all were selected, avoid collisions by chance */
        : GNUNET_CRYPTO_random_u32 (n_eligible);
    nsc.num_eligible = 0;
    GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                           &dv_neighbour_transmission,
                                           &nsc);
  }
}
 
 
static int
check_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
{
  uint16_t size = ntohs (dvb->header.size);
  uint16_t num_hops = ntohs (dvb->num_hops);
  uint16_t total_hops = ntohs (dvb->total_hops);
  uint16_t orig_size = ntohs (dvb->orig_size);
  const struct GNUNET_PeerIdentity *hops =
    (const struct GNUNET_PeerIdentity *) &dvb[1];
  const struct GNUNET_PeerIdentity *my_identity;
 
  (void) cls;
  if (size < sizeof(*dvb) + num_hops * sizeof(struct GNUNET_PeerIdentity)
      + sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((num_hops > MAX_DV_HOPS_ALLOWED) ||
      (total_hops > MAX_DV_HOPS_ALLOWED))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  /* #decaps_dv_box_cb() derives a VLA size from
     orig_size - sizeof(*dvb) - total_hops * sizeof (struct
     GNUNET_PeerIdentity); make sure that cannot underflow and that the
     remainder can plausibly hold a payload header plus a message. */
  if ((orig_size < size) ||
      (orig_size < sizeof(*dvb)
       + total_hops * sizeof(struct GNUNET_PeerIdentity)
       + sizeof(struct TransportDVBoxPayloadP)
       + sizeof(struct GNUNET_MessageHeader)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  /* This peer must not be on the path */
  for (unsigned int i = 0; i < num_hops; i++)
    if (0 == GNUNET_memcmp (&hops[i], my_identity))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
  return GNUNET_YES;
}
 
 
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)
{
  struct VirtualLink *vl = next_hop->vl;
  struct PendingMessage *pm;
  size_t msg_size = sizeof(struct TransportDVBoxMessage)
                    + num_hops * sizeof(struct GNUNET_PeerIdentity)
                    + enc_payload_size;
  char *buf;
  char msg_buf[msg_size] GNUNET_ALIGN;
  struct GNUNET_PeerIdentity *dhops;
 
  hdr->num_hops = htons (num_hops);
  hdr->total_hops = htons (total_hops);
  hdr->header.size = htons (msg_size);
  memcpy (msg_buf, hdr, sizeof(*hdr));
  dhops = (struct GNUNET_PeerIdentity *) &msg_buf[sizeof(struct
                                                         TransportDVBoxMessage)]
  ;
  memcpy (dhops, hops, num_hops * sizeof(struct GNUNET_PeerIdentity));
  memcpy (&dhops[num_hops], enc_payload, enc_payload_size);
 
  if (GNUNET_YES == ntohl (hdr->without_fc))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Forwarding control message (payload size %u) in DV Box to next hop %s (%u/%u) \n",
                enc_payload_size,
                GNUNET_i2s (&next_hop->pid),
                (unsigned int) num_hops,
                (unsigned int) total_hops);
    route_via_neighbour (next_hop, (const struct
                                    GNUNET_MessageHeader *) msg_buf,
                         RMO_ANYTHING_GOES);
  }
  else
  {
    pm = GNUNET_malloc (sizeof(struct PendingMessage) + msg_size);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "2 created pm %p storing vl %p \n",
                pm,
                vl);
    pm->pmt = PMT_DV_BOX;
    pm->vl = vl;
    pm->target = next_hop->pid;
    pm->timeout = GNUNET_TIME_relative_to_absolute (DV_FORWARD_TIMEOUT);
    pm->logging_uuid = logging_uuid_gen++;
    pm->prefs = GNUNET_MQ_PRIO_BACKGROUND;
    pm->bytes_msg = msg_size;
    buf = (char *) &pm[1];
    memcpy (buf, msg_buf, msg_size);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Created pending message %" PRIu64
                " for DV Box with next hop %s (%u/%u)\n",
                pm->logging_uuid,
                GNUNET_i2s (&next_hop->pid),
                (unsigned int) num_hops,
                (unsigned int) total_hops);
 
    if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
    {
      GNUNET_CONTAINER_MDLL_insert (vl,
                                    vl->pending_msg_head,
                                    vl->pending_msg_tail,
                                    pm);
 
      check_vl_transmission (vl);
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "The virtual link is not ready for forwarding a DV Box with payload, storing PendingMessage in ring buffer.\n");
 
      if (NULL != ring_buffer_dv[ring_buffer_dv_head])
      {
        struct PendingMessage *pm_old = ring_buffer_dv[ring_buffer_dv_head];
 
        GNUNET_free (pm_old);
      }
      ring_buffer_dv[ring_buffer_dv_head] = pm;
      if (RING_BUFFER_SIZE - 1 == ring_buffer_dv_head)
      {
        ring_buffer_dv_head = 0;
        is_ring_buffer_dv_full = GNUNET_YES;
      }
      else
        ring_buffer_dv_head++;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "%u items stored in DV ring buffer\n",
                  GNUNET_YES == is_ring_buffer_dv_full ? RING_BUFFER_SIZE :
                  ring_buffer_dv_head);
    }
  }
}
 
 
static void
free_backtalker (struct Backtalker *b)
{
  if (NULL != b->get)
  {
    GNUNET_PEERSTORE_iteration_stop (b->get);
    b->get = NULL;
    GNUNET_assert (NULL != b->cmc);
    finish_cmc_handling (b->cmc);
    b->cmc = NULL;
  }
  if (NULL != b->task)
  {
    GNUNET_SCHEDULER_cancel (b->task);
    b->task = NULL;
  }
  if (NULL != b->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (b->sc);
    b->sc = NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Removing backtalker for %s\n",
              GNUNET_i2s (&b->pid));
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (backtalkers, &b->pid, b));
  GNUNET_free (b);
}
 
 
static int
free_backtalker_cb (void *cls,
                    const struct GNUNET_PeerIdentity *pid,
                    void *value)
{
  struct Backtalker *b = value;
 
  (void) cls;
  (void) pid;
  free_backtalker (b);
  return GNUNET_OK;
}
 
 
static void
backtalker_timeout_cb (void *cls)
{
  struct Backtalker *b = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "backtalker timeout.\n");
  b->task = NULL;
  if (0 != GNUNET_TIME_absolute_get_remaining (b->timeout).rel_value_us)
  {
    b->task = GNUNET_SCHEDULER_add_at (b->timeout, &backtalker_timeout_cb, b);
    return;
  }
  /* A monotime store may well still be in flight -- @e timeout is about how
     long the *peer* has been quiet, and says nothing about PEERSTORE.  This
     used to `GNUNET_assert (NULL == b->sc)', which aborted the service in
     exactly that case.  #free_backtalker() cancels the store. */
  free_backtalker (b);
}
 
 
static void
backtalker_monotime_cb (void *cls,
                        const struct GNUNET_PEERSTORE_Record *record,
                        const char *emsg)
{
  struct Backtalker *b = cls;
  struct GNUNET_TIME_AbsoluteNBO *mtbe;
  struct GNUNET_TIME_Absolute mt;
 
  (void) emsg;
  if (NULL == record)
  {
    struct CommunicatorMessageContext *cmc;
 
    /* we're done with #backtalker_monotime_cb() invocations,
       continue normal processing */
    b->get = NULL;
    GNUNET_assert (NULL != b->cmc);
    /* Take @e cmc out of @a b *before* dispatching: the dispatch runs
       arbitrary message handling, and writing `b->cmc = NULL' afterwards
       is a write to freed memory should anything on that path have
       released @a b.  #free_backtalker() keys its "must finish the parked
       cmc" decision off @e get, which is already NULL here, so clearing
       @e cmc early cannot lose the message either. */
    cmc = b->cmc;
    b->cmc = NULL;
    cmc->mh = (const struct GNUNET_MessageHeader *) &b[1];
    if (0 != b->body_size)
      demultiplex_with_cmc (cmc);
    else
      finish_cmc_handling (cmc);
    return;
  }
  if (sizeof(*mtbe) != record->value_size)
  {
    GNUNET_PEERSTORE_iteration_next (b->get, 1);
    GNUNET_break (0);
    return;
  }
  mtbe = record->value;
  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
  if (mt.abs_value_us > b->monotonic_time.abs_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Backtalker message from %s dropped, monotime in the past\n",
                GNUNET_i2s (&b->pid));
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Backchannel messages dropped: monotonic time not increasing",
      1,
      GNUNET_NO);
    b->monotonic_time = mt;
    /* Setting body_size to 0 prevents call to #forward_backchannel_payload()
     */
    b->body_size = 0;
  }
  GNUNET_PEERSTORE_iteration_next (b->get, 1);
}
 
 
static void
backtalker_monotime_store_cb (void *cls, int success)
{
  struct Backtalker *b = cls;
 
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store backtalker's monotonic time in PEERSTORE!\n");
  }
  b->sc = NULL;
  /* @e task is armed for the whole life of @a b -- #backtalker_timeout_cb()
     re-arms itself whenever @e timeout has moved forward -- so there is
     nothing to do here beyond releasing the store.  It used to cancel and
     re-add the task, which is what made the task's existence depend on this
     callback ever running. */
  GNUNET_assert (NULL != b->task);
}
 
 
static void
update_backtalker_monotime (struct Backtalker *b)
{
  struct GNUNET_TIME_AbsoluteNBO mtbe;
 
  /* At most one store may be outstanding.  The value we are about to write
     supersedes whatever the previous one carried, and leaving the old
     context alive means its completion clears @e sc while the newer store
     is still in flight -- after which the next update sees a NULL @e sc and
     starts a third one.  Cancelling is also what keeps @e sc from being
     silently overwritten and leaked.
 
     Note what this must NOT do: touch @e task.  That task is the only thing
     that ever releases a `struct CommunicatorMessageContext' parked in
     @e cmc, and cancelling it here left its re-arming up to
     #backtalker_monotime_store_cb() -- i.e. up to PEERSTORE answering.  A
     lost store completion then stalled the parked communicator client for
     the life of the process.  #backtalker_timeout_cb() already re-arms
     itself against the current @e timeout, so the task needs no help. */
  if (NULL != b->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Superseding in-flight backtalker monotime store %p\n",
                b->sc);
    GNUNET_PEERSTORE_store_cancel (b->sc);
    b->sc = NULL;
  }
  mtbe = GNUNET_TIME_absolute_hton (b->monotonic_time);
  b->sc =
    GNUNET_PEERSTORE_store (peerstore,
                            "transport",
                            &b->pid,
                            GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME,
                            &mtbe,
                            sizeof(mtbe),
                            GNUNET_TIME_UNIT_FOREVER_ABS,
                            GNUNET_PEERSTORE_STOREOPTION_REPLACE,
                            &backtalker_monotime_store_cb,
                            b);
}
 
 
static void
decaps_dv_box_cont (struct CommunicatorMessageContext *cmc,
                    const struct TransportDVBoxMessage *dvb,
                    const struct GNUNET_ShortHashCode *km)
{
  const unsigned char *hdr;
  size_t hdr_len;
  struct GNUNET_CRYPTO_AeadSecretKey *key;
 
  key = (struct GNUNET_CRYPTO_AeadSecretKey*) km;
  /* We are the ultimate target, so #handle_dv_box() has established that no
     hop entries are left: the ciphertext directly follows the header, and
     its length is what we actually received.  Deriving it from orig_size
     and total_hops instead would only be equivalent if every forwarder
     accounted its skipped hops exactly. */
  hdr = (const unsigned char *) &dvb[1];
  {
    uint16_t size = ntohs (dvb->header.size);
 
    if (size < sizeof(*dvb)
        + sizeof(struct TransportDVBoxPayloadP)
        + sizeof(struct GNUNET_MessageHeader))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    hdr_len = size - sizeof(*dvb);
  }
 
  /* begin actual decryption */
  {
    struct Backtalker *b;
    struct GNUNET_TIME_Absolute monotime;
    struct TransportDVBoxPayloadP *ppay;
    unsigned char pt[hdr_len + sizeof *ppay] GNUNET_ALIGN;
    unsigned char *body;
    const struct GNUNET_MessageHeader *mh;
 
    ppay = (struct TransportDVBoxPayloadP *) pt;
    body = &pt[sizeof *ppay];
    GNUNET_assert (hdr_len >=
                   sizeof(*ppay) + sizeof(struct GNUNET_MessageHeader));
    if (GNUNET_OK != GNUNET_CRYPTO_aead_decrypt (hdr_len,
                                                 hdr,
                                                 0,
                                                 NULL,
                                                 key,
                                                 &dvb->iv,
                                                 &dvb->mac,
                                                 pt))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Error decrypting DV payload header\n");
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    mh = (const struct GNUNET_MessageHeader *) body;
    /* NOTE: this used to compare against `sizeof (body)', i.e. the size of
       a pointer, which meant only 8-byte payloads were ever accepted. */
    if (ntohs (mh->size) != hdr_len - sizeof(*ppay))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    /* need to prevent box-in-a-box (and DV_LEARN) so check inbox type! */
    switch (ntohs (mh->type))
    {
    case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX:
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
 
    case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN:
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
 
    default:
      /* permitted, continue */
      break;
    }
    monotime = GNUNET_TIME_absolute_ntoh (ppay->monotonic_time);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Decrypted backtalk from %s\n",
                GNUNET_i2s (&ppay->sender));
    b = GNUNET_CONTAINER_multipeermap_get (backtalkers,
                                           &ppay->sender);
    if ((NULL != b) && (monotime.abs_value_us < b->monotonic_time.abs_value_us))
    {
      GNUNET_STATISTICS_update (
        GST_stats,
        "# Backchannel messages dropped: monotonic time not increasing",
        1,
        GNUNET_NO);
      finish_cmc_handling (cmc);
      return;
    }
    if ((NULL == b) ||
        (0 != GNUNET_memcmp (&b->last_ephemeral, &dvb->ephemeral_key)))
    {
      /* Check signature */
      const struct GNUNET_PeerIdentity *my_identity;
      struct EphemeralConfirmationPS ec;
 
      my_identity = GNUNET_PILS_get_identity (pils);
      GNUNET_assert (my_identity);
 
      ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
      ec.target = *my_identity;
      ec.ephemeral_key = dvb->ephemeral_key;
      ec.purpose.size =  htonl (sizeof(ec));
      ec.sender_monotonic_time = ppay->monotonic_time;
      if (
        GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_verify (
          GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL,
          &ec,
          &ppay->sender_sig,
          &ppay->sender.public_key))
      {
        /* Signature invalid, discard! */
        GNUNET_break_op (0);
        finish_cmc_handling (cmc);
        return;
      }
    }
    /* Update sender, we now know the real origin! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "DVBox received for me from %s via %s\n",
                GNUNET_i2s2 (&ppay->sender),
                GNUNET_i2s (&cmc->im.sender));
    cmc->im.sender = ppay->sender;
 
    if (NULL != b)
    {
      /* update key cache and mono time */
      b->last_ephemeral = dvb->ephemeral_key;
      b->monotonic_time = monotime;
      update_backtalker_monotime (b);
      b->timeout =
        GNUNET_TIME_relative_to_absolute (BACKCHANNEL_INACTIVITY_TIMEOUT);
      cmc->mh = mh;
      demultiplex_with_cmc (cmc);
      return;
    }
    /* setup data structure to cache signature AND check
       monotonic time with PEERSTORE before forwarding backchannel payload */
    b = GNUNET_malloc (sizeof(struct Backtalker) + (hdr_len - sizeof(*ppay)));
    b->pid = ppay->sender;
    b->body_size = hdr_len - sizeof(*ppay);
    memcpy (&b[1], body, hdr_len - sizeof(*ppay));
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_put (
                     backtalkers,
                     &b->pid,
                     b,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    b->monotonic_time = monotime; /* NOTE: to be checked still! */
    b->cmc = cmc;
    b->timeout =
      GNUNET_TIME_relative_to_absolute (BACKCHANNEL_INACTIVITY_TIMEOUT);
    b->task = GNUNET_SCHEDULER_add_at (b->timeout, &backtalker_timeout_cb, b);
    b->get =
      GNUNET_PEERSTORE_iteration_start (peerstore,
                                        "transport",
                                        &b->pid,
                                        GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME,
                                        &backtalker_monotime_cb,
                                        b);
  } /* end actual decryption */
}
 
 
static void
handle_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
{
  struct CommunicatorMessageContext *cmc = cls;
  uint16_t size = ntohs (dvb->header.size) - sizeof(*dvb);
  uint16_t num_hops = ntohs (dvb->num_hops);
  const struct GNUNET_PeerIdentity *hops =
    (const struct GNUNET_PeerIdentity *) &dvb[1];
  const char *enc_payload = (const char *) &hops[num_hops];
  uint16_t enc_payload_size =
    size - (num_hops * sizeof(struct GNUNET_PeerIdentity));
  const struct GNUNET_PeerIdentity *my_identity;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  if (GNUNET_EXTRA_LOGGING > 0)
  {
    char *path;
 
    path = GNUNET_strdup (GNUNET_i2s (my_identity));
    for (unsigned int i = 0; i < num_hops; i++)
    {
      char *tmp;
 
      GNUNET_asprintf (&tmp, "%s->%s", path, GNUNET_i2s (&hops[i]));
      GNUNET_free (path);
      path = tmp;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received DVBox with remaining path %s\n",
                path);
    GNUNET_free (path);
  }
 
  if (num_hops > 0)
  {
    /* We're trying from the end of the hops array, as we may be
       able to find a shortcut unknown to the origin that way */
    for (int i = num_hops - 1; i >= 0; i--)
    {
      struct Neighbour *n;
 
      if (0 == GNUNET_memcmp (&hops[i], my_identity))
      {
        GNUNET_break_op (0);
        finish_cmc_handling (cmc);
        return;
      }
      n = lookup_neighbour (&hops[i]);
      if (NULL == n)
        continue;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Skipping %u/%u hops ahead while routing DV Box\n",
                  i,
                  num_hops);
 
      forward_dv_box (n,
                      (struct TransportDVBoxMessage *) dvb,
                      /* we strip i+1 entries, and the receiver reconstructs
                         the ciphertext offset from total_hops */
                      ntohs (dvb->total_hops) + i + 1,
                      num_hops - i - 1,    /* number of hops left */
                      &hops[i + 1],    /* remaining hops */
                      enc_payload,
                      enc_payload_size);
      GNUNET_STATISTICS_update (GST_stats,
                                "# DV hops skipped routing boxes",
                                i,
                                GNUNET_NO);
      GNUNET_STATISTICS_update (GST_stats,
                                "# DV boxes routed (total)",
                                1,
                                GNUNET_NO);
      finish_cmc_handling (cmc);
      return;
    }
    /* Woopsie, next hop not in neighbours, drop! */
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV Boxes dropped: next hop unknown",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  /* We are the target. Unbox and handle message. */
  GNUNET_STATISTICS_update (GST_stats,
                            "# DV boxes opened (ultimate target)",
                            1,
                            GNUNET_NO);
  cmc->total_hops = ntohs (dvb->total_hops);
 
  {
    // DH key derivation with received DV, could be garbage.
    const struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
    struct GNUNET_ShortHashCode km;
 
    my_private_key = GNUNET_PILS_get_private_key (pils);
    if ( (NULL == my_private_key) ||
         (GNUNET_OK !=
          GNUNET_CRYPTO_eddsa_kem_decaps (my_private_key,
                                          &dvb->ephemeral_key,
                                          &km)) )
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    decaps_dv_box_cont (cmc,
                        dvb,
                        &km);
  }
}
 
 
static int
check_incoming_msg (void *cls,
                    const struct GNUNET_TRANSPORT_IncomingMessage *im)
{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_MQ_check_boxed_message (im);
  return GNUNET_OK;
}
 
 
struct CheckKnownAddressContext
{
  const char *address;
 
  struct ValidationState *vs;
};
 
 
static int
check_known_address (void *cls,
                     const struct GNUNET_PeerIdentity *pid,
                     void *value)
{
  struct CheckKnownAddressContext *ckac = cls;
  struct ValidationState *vs = value;
 
  (void) pid;
  if (0 != strcmp (vs->address, ckac->address))
    return GNUNET_OK;
  ckac->vs = vs;
  return GNUNET_NO;
}
 
 
static void
validation_start_cb (void *cls);
 
 
static void
update_next_challenge_time (struct ValidationState *vs,
                            struct GNUNET_TIME_Absolute new_time)
{
  struct GNUNET_TIME_Relative delta;
  struct ValidationState *next;
 
  /* NOTE: "be lazy" must not apply while #validation_task is unset.  Our
     only caller that can leave it unset is #validation_start_cb(), which
     NULLs it on entry and relies on us to arm it again -- and nothing else
     ever does.  Returning early there stops address (re)validation and the
     #suggest_to_connect() retries that go with it for *every* peer, for
     good. */
  if ((new_time.abs_value_us == vs->next_challenge.abs_value_us) &&
      (NULL != validation_task) &&
      (NULL != vs->hn))
    return; /* be lazy */
  vs->next_challenge = new_time;
  if (NULL == vs->hn)
    vs->hn =
      GNUNET_CONTAINER_heap_insert (validation_heap, vs, new_time.abs_value_us);
  else
    GNUNET_CONTAINER_heap_update_cost (vs->hn, new_time.abs_value_us);
  if ((vs != GNUNET_CONTAINER_heap_peek (validation_heap)) &&
      (NULL != validation_task))
    return;
  if (NULL != validation_task)
    GNUNET_SCHEDULER_cancel (validation_task);
  /* Arm for the earliest entry in the heap, which need NOT be @a vs:
     #validation_start_cb() calls us with @e validation_task unset and with
     @a vs already pushed out to its new @e challenge_backoff, which doubles
     up to #MAX_VALIDATION_CHALLENGE_FREQ (one day) while an address stays
     unanswered.  Arming for @a vs there parks the single global validation
     task for that long, no matter how many other addresses are due right
     now -- and every address of a peer we cannot reach (NAT) is such an
     address.  Everything that needs a validation then stops with it:
     bringing a lost link back up, and confirming the link to a peer that
     contacted us. */
  next = GNUNET_CONTAINER_heap_peek (validation_heap);
  if (NULL == next)
    return;
  /* randomize a bit */
  delta.rel_value_us =
    GNUNET_CRYPTO_random_u64 (MIN_DELAY_ADDRESS_VALIDATION.rel_value_us);
  validation_task =
    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_add (next->next_challenge,
                                                       delta),
                             &validation_start_cb,
                             NULL);
}
 
 
static void
speed_up_challenge (struct ValidationState *vs)
{
  vs->challenge_backoff = FAST_VALIDATION_CHALLENGE_FREQ;
}
 
 
static enum GNUNET_GenericReturnValue
revalidate_now_cb (void *cls,
                   const struct GNUNET_PeerIdentity *pid,
                   void *value)
{
  struct ValidationState *vs = value;
  const struct GNUNET_TIME_Absolute now =
    GNUNET_TIME_absolute_get_monotonic (GST_cfg);
 
  (void) cls;
  (void) pid;
  /* What #start_address_validation() does for an address it hears about
     again, but without needing the address string. */
  speed_up_challenge (vs);
  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
    vs->first_challenge_use = now;
  update_next_challenge_time (vs,
                              GNUNET_TIME_relative_to_absolute (
                                vs->challenge_backoff));
  return GNUNET_OK;
}
 
 
static void
start_address_validation (const struct GNUNET_PeerIdentity *pid,
                          const char *address)
{
  struct GNUNET_TIME_Absolute now;
  struct ValidationState *vs;
  struct CheckKnownAddressContext ckac = { .address = address, .vs = NULL };
 
  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
                                                     pid,
                                                     &check_known_address,
                                                     &ckac);
  now = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  if (NULL != (vs = ckac.vs))
  {
    const struct VirtualLink *vl = lookup_virtual_link (pid);
 
    /* Speed up retrying the validation if 'vs' is not currently valid, or if
     * we have no confirmed virtual link to @a pid.  In the latter case the
     * address may still be well inside its validity window -- but the link is
     * down, and #handle_validation_response() is the only thing that can
     * rebuild it and tell CORE about the peer again.  Without this we would
     * wait for @e revalidation_task, which does not fire until
     * #ADDRESS_VALIDATION_LIFETIME is nearly over. */
    if ((vs->validated_until.abs_value_us < vs->next_challenge.abs_value_us) ||
        (NULL == vl) ||
        (GNUNET_NO == vl->confirmed))
    {
      /* reduce backoff as we got a fresh advertisement */
      speed_up_challenge (vs);
      /* A successful validation parks @e first_challenge_use just before
         @e validated_until, so that the *next* challenge is not used before
         the current validation is about to expire.  #validation_start_cb()
         refuses to run while that time is still in the future, so pulling
         @e next_challenge in without this would only make it reschedule
         itself four hours out.  The challenge has not been used yet, so
         moving the start of its window to now stays truthful -- it is what
         the fresh-@a vs path below does as well. */
      if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
        vs->first_challenge_use = now;
      update_next_challenge_time (vs,
                                  GNUNET_TIME_relative_to_absolute (
                                    vs->challenge_backoff));
    }
    return;
  }
  vs = GNUNET_new (struct ValidationState);
  vs->pid = *pid;
  vs->valid_until =
    GNUNET_TIME_relative_to_absolute (ADDRESS_VALIDATION_LIFETIME);
  vs->first_challenge_use = now;
  vs->validation_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
  GNUNET_CRYPTO_random_block (&vs->challenge,
                              sizeof(vs->challenge));
  vs->address = GNUNET_strdup (address);
  {
    /* The peer identity MUST be part of @e hc: two peers behind the same NAT
       advertise the very same address string (`PROTO-IP:0'), and with an
       address-only key the second one's #revalidation_map entry would be
       rejected as a duplicate of the first one's. */
    struct GNUNET_HashContext *hsh;
 
    hsh = GNUNET_CRYPTO_hash_context_start ();
    GNUNET_CRYPTO_hash_context_read (hsh, vs->address, strlen (vs->address));
    GNUNET_CRYPTO_hash_context_read (hsh, &vs->pid, sizeof(vs->pid));
    GNUNET_CRYPTO_hash_context_finish (hsh, &vs->hc);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting address validation `%s' of peer %s using challenge %s\n",
              address,
              GNUNET_i2s (pid),
              GNUNET_sh2s (&vs->challenge.value));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (
                   validation_map,
                   &vs->pid,
                   vs,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  update_next_challenge_time (vs, now);
}
 
 
static struct Queue *
find_queue (const struct GNUNET_PeerIdentity *pid, const char *address);
 
 
static void
suggest_to_connect (const struct GNUNET_PeerIdentity *pid, const char *address);
 
 
static void
hello_for_incoming_cb (void *cls,
                       const struct GNUNET_PeerIdentity *pid,
                       const char *uri)
{
  struct Queue *q;
  int pfx_len;
  const char *eou;
  char *address;
  (void) cls;
 
  eou = strstr (uri,
                "://");
  if ((NULL == eou) || (eou == uri))
  {
    /* @a uri comes from a HELLO some remote peer published. */
    GNUNET_break_op (0);
    return;
  }
  pfx_len = eou - uri;
  eou += 3;
  GNUNET_asprintf (&address,
                   "%.*s-%s",
                   pfx_len,
                   uri,
                   eou);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "helo for client %s\n",
              address);
  q = find_queue (pid, address);
  if (NULL == q)
  {
    suggest_to_connect (pid, address);
  }
  else
    start_address_validation (pid, address);
  GNUNET_free (address);
}
 
 
static const struct GNUNET_MessageHeader *
hello_from_record (const struct GNUNET_PEERSTORE_Record *record)
{
  const struct GNUNET_MessageHeader *hello;
 
  if ((NULL == record) ||
      (NULL == record->value) ||
      (record->value_size < sizeof(*hello)))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  hello = record->value;
  if (ntohs (hello->size) > record->value_size)
  {
    GNUNET_break_op (0);
    return NULL;
  }
  return hello;
}
 
 
static void
handle_hello_for_incoming (void *cls,
                           const struct GNUNET_PEERSTORE_Record *record,
                           const char *emsg)
{
  struct IncomingRequest *ir = cls;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_MessageHeader *hello;
  const struct GNUNET_PeerIdentity *my_identity;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  hello = hello_from_record (record);
  if (NULL == hello)
  {
    /* MUST still ask for the next record: a bad one is not a reason to
       stall this monitor forever. */
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  if (0 == GNUNET_memcmp (&record->peer, my_identity))
  {
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  if (0 != GNUNET_memcmp (&record->peer, &ir->pid))
  {
    /* Not the peer this request is about. */
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
  if (NULL != parser)
  {
    GNUNET_HELLO_parser_iterate (parser,
                                 hello_for_incoming_cb,
                                 NULL);
    GNUNET_HELLO_parser_free (parser);
  }
  /* MUST ask for the next record, or this monitor stalls after one HELLO */
  GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
}
 
 
static void
hello_for_incoming_error_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}
 
 
static void
hello_for_incoming_sync_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Done with initial PEERSTORE iteration during monitoring\n");
}
 
 
static void
try_to_bring_link_up (const struct GNUNET_PeerIdentity *pid)
{
  struct Neighbour *n;
  struct IncomingRequest *ir;
 
  if (GNUNET_YES == in_shutdown)
    return;
  /* (1) Addresses we already track.  These outlive the queues, which is the
     point: once a link is down the queue that carried it is usually gone,
     so there is no address string left for #start_address_validation(). */
  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
                                                     pid,
                                                     &revalidate_now_cb,
                                                     NULL);
  /* (2) Queues we still have; may cover an address with no validation state
     yet.  After (1), because it may insert into #validation_map. */
  n = lookup_neighbour (pid);
  if (NULL != n)
    for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
      start_address_validation (pid, q->address);
  /* (3) Failing that, look for an address in PEERSTORE. */
  for (ir = ir_head; NULL != ir; ir = ir->next)
  {
    if (0 == GNUNET_memcmp (&ir->pid, pid))
      return;   /* we are already trying */
  }
  ir = GNUNET_new (struct IncomingRequest);
  ir->pid = *pid;
  GNUNET_CONTAINER_DLL_insert (ir_head, ir_tail, ir);
  /* Monitor only @a pid: with NULL every request sees every HELLO in
     PEERSTORE, so each of the up to #MAX_INCOMING_REQUEST requests started
     a connection attempt and an address validation for peers it was not
     created for. */
  ir->nc = GNUNET_PEERSTORE_monitor_start (GST_cfg,
                                           GNUNET_YES,
                                           "peerstore",
                                           &ir->pid,
                                           GNUNET_PEERSTORE_HELLO_KEY,
                                           &hello_for_incoming_error_cb,
                                           NULL,
                                           &hello_for_incoming_sync_cb,
                                           NULL,
                                           &handle_hello_for_incoming,
                                           ir);
  ir_total++;
  /* Bound attempts we do in parallel here, might otherwise get excessive.
     Drop the OLDEST request: #ir_head is the one we just inserted, so
     freeing that would immediately undo the work above. */
  while (ir_total > MAX_INCOMING_REQUEST)
    free_incoming_request (ir_tail);
}
 
 
static void
send_t_validation_response (struct CommunicatorMessageContext *cmc,
                            struct TransportValidationResponseMessage tvr)
{
  struct VirtualLink *vl;
  struct Neighbour *n;
  struct GNUNET_PeerIdentity sender;
 
  sender = cmc->im.sender;
  vl = lookup_virtual_link (&sender);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    // route_control_message_without_fc (&cmc->im.sender,
    route_control_message_without_fc (vl,
                                      &tvr.header,
                                      RMO_ANYTHING_GOES | RMO_REDUNDANT);
  }
  else
  {
    /* Use route via neighbour */
    n = lookup_neighbour (&sender);
    if (NULL != n)
      route_via_neighbour (n, &tvr.header,
                           RMO_ANYTHING_GOES | RMO_REDUNDANT
                           | RMO_UNCONFIRMED_ALLOWED);
  }
 
  finish_cmc_handling (cmc);
  /* An *unconfirmed* link is not a link -- it carries nothing, and CORE has
     never been told about the peer.  Bailing out on one merely because it
     exists is what deadlocks a pair of peers into permanent one-way state:
     the challenger validated us, so it believes the connection is up and
     starts sending us FLOW_CONTROL; #handle_flow_control() answers an
     unknown sender by allocating exactly such an unconfirmed link; and from
     then on every challenge it retransmits lands here, gets a response --
     which keeps *its* side confirmed and its RTT healthy -- and returns
     without ever validating an address of its own.  The unconfirmed link
     reaps itself after #UNCONFIRMED_LINK_TIMEOUT, but the next FLOW_CONTROL
     recreates it, and the peer keeps sending those precisely because it
     thinks it is connected.  Nothing ever breaks the tie, so CORE on this
     side never hears about the peer and never answers its handshake.
     Only a confirmed link means there is nothing left to do. */
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
    return;
 
  /* For us, the link is still down, but we need bi-directional
     connections (for flow-control and for this to be useful for
     CORE), so we must try to bring the link up! */
  try_to_bring_link_up (&sender);
}
 
 
static void
handle_validation_challenge (
  void *cls,
  const struct TransportValidationChallengeMessage *tvc)
{
  struct CommunicatorMessageContext *cmc = cls;
  struct TransportValidationResponseMessage tvr = { 0 };
  struct GNUNET_TIME_RelativeNBO validity_duration;
 
  /* DV-routed messages are not allowed for validation challenges */
  if (cmc->total_hops > 0)
  {
    GNUNET_break_op (0);
    finish_cmc_handling (cmc);
    return;
  }
  validity_duration = cmc->im.expected_address_validity;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received address validation challenge %s\n",
              GNUNET_sh2s (&tvc->challenge.value));
  /* If we have a virtual link, we use this mechanism to signal the
     size of the flow control window, and to allow the sender
     to ask for increases. If for us the virtual link is still down,
     we will always give a window size of zero. */
  tvr.header.type =
    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE);
  tvr.header.size = htons (sizeof(tvr));
  tvr.reserved = htonl (0);
  tvr.challenge = tvc->challenge;
  tvr.origin_time = tvc->sender_time;
  tvr.validity_duration = validity_duration;
  {
    /* create signature */
    struct TransportValidationPS tvp = {
      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
      .purpose.size = htonl (sizeof(tvp)),
      .validity_duration = validity_duration,
      .challenge = tvc->challenge
    };
    if (GNUNET_OK != sign_by_my_identity (&tvp.purpose, &tvr.signature))
    {
      /* Not answering costs us this address validation; leaving @a cmc
         behind would cost us the communicator. */
      finish_cmc_handling (cmc);
      return;
    }
  }
  send_t_validation_response (cmc, tvr);
}
 
 
struct CheckKnownChallengeContext
{
  const struct GNUNET_CRYPTO_ChallengeNonceP *challenge;
 
  struct ValidationState *vs;
};
 
 
static int
check_known_challenge (void *cls,
                       const struct GNUNET_PeerIdentity *pid,
                       void *value)
{
  struct CheckKnownChallengeContext *ckac = cls;
  struct ValidationState *vs = value;
 
  (void) pid;
  if (0 != GNUNET_memcmp (&vs->challenge, ckac->challenge))
    return GNUNET_OK;
  ckac->vs = vs;
  return GNUNET_NO;
}
 
 
static void
peerstore_store_validation_cb (void *cls, int success)
{
  struct ValidationState *vs = cls;
 
  vs->sc = NULL;
  if (GNUNET_YES == success)
    return;
  GNUNET_STATISTICS_update (GST_stats,
                            "# Peerstore failed to store foreign address",
                            1,
                            GNUNET_NO);
}
 
 
static struct Queue *
find_queue (const struct GNUNET_PeerIdentity *pid, const char *address)
{
  struct Neighbour *n;
 
  n = lookup_neighbour (pid);
  if (NULL == n)
    return NULL;
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    if (0 == strcmp (pos->address, address))
      return pos;
  }
  return NULL;
}
 
 
static struct Queue *
find_queue_by_ip (const struct GNUNET_PeerIdentity *pid, const char *address)
{
  struct Neighbour *n;
  struct Queue *ret = NULL;
  char *prefix;
  char *ip;
 
  n = lookup_neighbour (pid);
  if (NULL == n)
    return NULL;
  prefix = GNUNET_HELLO_address_to_prefix (address);
  ip = get_address_without_port (address);
  if ((NULL == prefix) || (NULL == ip))
  {
    GNUNET_free (prefix);
    GNUNET_free (ip);
    return NULL;
  }
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    char *q_prefix = GNUNET_HELLO_address_to_prefix (pos->address);
    char *q_ip = get_address_without_port (pos->address);
 
    /* Same communicator and same host -- only the port may differ. */
    if ((NULL != q_prefix) && (NULL != q_ip) &&
        (0 == strcmp (q_prefix, prefix)) &&
        (0 == strcmp (q_ip, ip)))
      ret = pos;
    GNUNET_free (q_prefix);
    GNUNET_free (q_ip);
    if (NULL != ret)
      break;
  }
  GNUNET_free (prefix);
  GNUNET_free (ip);
  return ret;
}
 
 
static void
validation_transmit_on_queue (struct Queue *q, struct ValidationState *vs);
 
static void
revalidation_start_cb (void *cls)
{
  struct ValidationState *vs = cls;
  struct Queue *q;
  struct GNUNET_TIME_Absolute now;
 
  vs->revalidation_task = NULL;
  q = find_queue (&vs->pid, vs->address);
  if (NULL == q)
  {
    now = GNUNET_TIME_absolute_get ();
    vs->awaiting_queue = GNUNET_YES;
    suggest_to_connect (&vs->pid, vs->address);
    update_next_challenge_time (vs, now);
  }
  else
    validation_transmit_on_queue (q, vs);
}
 
 
static enum GNUNET_GenericReturnValue
revalidate_map_it (
  void *cls,
  const struct GNUNET_HashCode *key,
  void *value)
{
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Key in revalidate map  %s \n",
              GNUNET_h2s (key));
  return GNUNET_YES;
}
 
 
static void
handle_validation_response (
  void *cls,
  const struct TransportValidationResponseMessage *tvr)
{
  struct CommunicatorMessageContext *cmc = cls;
  struct ValidationState *vs;
  struct CheckKnownChallengeContext ckac = { .challenge = &tvr->challenge,
                                             .vs = NULL};
  struct GNUNET_TIME_Absolute origin_time;
  struct Queue *q;
  struct Neighbour *n;
  struct VirtualLink *vl;
  const struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get_monotonic (
    GST_cfg);
 
  /* check this is one of our challenges */
  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
                                                     &cmc->im.sender,
                                                     &check_known_challenge,
                                                     &ckac);
  if (NULL == (vs = ckac.vs))
  {
    /* This can happen simply if we 'forgot' the challenge by now,
       i.e. because we received the validation response twice */
    GNUNET_STATISTICS_update (GST_stats,
                              "# Validations dropped, challenge unknown",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Validation response %s dropped, challenge unknown\n",
                GNUNET_sh2s (&tvr->challenge.value));
    finish_cmc_handling (cmc);
    return;
  }
 
  /* sanity check on origin time */
  origin_time = GNUNET_TIME_absolute_ntoh (tvr->origin_time);
  if ((origin_time.abs_value_us < vs->first_challenge_use.abs_value_us) ||
      (origin_time.abs_value_us > vs->last_challenge_use.abs_value_us))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Diff first use %" PRIu64 " and last use %" PRIu64 "\n",
                vs->first_challenge_use.abs_value_us - origin_time.abs_value_us,
                origin_time.abs_value_us - vs->last_challenge_use.abs_value_us);
    GNUNET_break_op (0);
    finish_cmc_handling (cmc);
    return;
  }
 
  {
    /* check signature */
    struct TransportValidationPS tvp = {
      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
      .purpose.size = htonl (sizeof(tvp)),
      .validity_duration = tvr->validity_duration,
      .challenge = tvr->challenge
    };
 
    if (
      GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE,
                                  &tvp,
                                  &tvr->signature,
                                  &cmc->im.sender.public_key))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
  }
 
  /* validity is capped by our willingness to keep track of the
     validation entry and the maximum the other peer allows */
  vs->valid_until = GNUNET_TIME_relative_to_absolute (
    GNUNET_TIME_relative_min (GNUNET_TIME_relative_ntoh (
                                tvr->validity_duration),
                              MAX_ADDRESS_VALID_UNTIL));
  vs->validated_until =
    GNUNET_TIME_absolute_min (vs->valid_until,
                              GNUNET_TIME_relative_to_absolute (
                                ADDRESS_VALIDATION_LIFETIME));
  vs->validation_rtt = GNUNET_TIME_absolute_get_duration (origin_time);
  vs->challenge_backoff = GNUNET_TIME_UNIT_ZERO;
  GNUNET_CRYPTO_random_block (&vs->challenge,
                              sizeof(vs->challenge));
  vs->first_challenge_use = GNUNET_TIME_absolute_subtract (
    vs->validated_until,
    GNUNET_TIME_relative_multiply (vs->validation_rtt,
                                   VALIDATION_RTT_BUFFER_FACTOR));
  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, <, now))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "First challenge use is now %" PRIu64 " %s \n",
                vs->first_challenge_use.abs_value_us,
                GNUNET_sh2s (&vs->challenge.value));
    vs->first_challenge_use = now;
  }
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "First challenge use is later %" PRIu64 " %s \n",
                vs->first_challenge_use.abs_value_us,
                GNUNET_sh2s (&vs->challenge.value));
  vs->last_challenge_use =
    GNUNET_TIME_UNIT_ZERO_ABS; /* challenge was not yet used */
  update_next_challenge_time (vs, vs->first_challenge_use);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Validation response %s from %s accepted, address valid until %s\n",
              GNUNET_sh2s (&tvr->challenge.value),
              GNUNET_i2s (&cmc->im.sender),
              GNUNET_STRINGS_absolute_time_to_string (vs->valid_until));
  /*memcpy (&hkey,
          &hc,
          sizeof (hkey));*/
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Key %s for address %s map size %u contains %u\n",
              GNUNET_h2s (&vs->hc),
              vs->address,
              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
                                                      &vs->hc));
  /* NOTE: @e hc hashes the address only, so two `struct ValidationState's
     for different peers can collide here.  That must not abort us. */
  if (GNUNET_YES !=
      GNUNET_CONTAINER_multihashmap_put (
        revalidation_map,
        &vs->hc,
        vs,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Address `%s' already tracked for revalidation\n",
                vs->address);
  GNUNET_CONTAINER_multihashmap_iterate (revalidation_map,
                                         revalidate_map_it,
                                         NULL);
  vs->revalidation_task =
    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_subtract (vs->next_challenge,
                                                            GNUNET_TIME_UNIT_MINUTES),
                             &revalidation_start_cb, vs);
  vs->sc = GNUNET_PEERSTORE_store (peerstore,
                                   "transport",
                                   &cmc->im.sender,
                                   GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY,
                                   vs->address,
                                   strlen (vs->address) + 1,
                                   vs->valid_until,
                                   GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
                                   &peerstore_store_validation_cb,
                                   vs);
  finish_cmc_handling (cmc);
 
  /* Finally, we now possibly have a confirmed (!) working queue,
     update queue status (if queue still is around) */
  q = find_queue (&vs->pid, vs->address);
  if (NULL == q)
  {
    /* The challenge may have gone out on a queue whose address is not
       literally @e address: #check_validation_request_pending() matches on
       the IP alone, precisely so that a validation waiting for the NAT
       address `PROTO-IP:0' can be answered over the queue that the peer
       actually established from `PROTO-IP:port'.  Insisting on an exact
       match here would silently discard that (successful!) validation and
       never bring the virtual link up. */
    q = find_queue_by_ip (&vs->pid, vs->address);
  }
  if (NULL == q)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# Queues lost at time of successful validation",
                              1,
                              GNUNET_NO);
    return;
  }
  q->validated_until = vs->validated_until;
  q->pd.aged_rtt = vs->validation_rtt;
  n = q->neighbour;
  vl = lookup_virtual_link (&vs->pid);
  if (NULL == vl)
  {
    vl = GNUNET_new (struct VirtualLink);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Creating new virtual link %p to %s using direct neighbour!\n",
                vl,
                GNUNET_i2s (&vs->pid));
    vl->burst_addr = NULL;
    vl->confirmed = GNUNET_YES;
    vl->message_uuid_ctr =
      GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    vl->target = n->pid;
    vl->core_recv_window = RECV_WINDOW_SIZE;
    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
    /* What the peer will grant us in its very first FLOW_CONTROL anyway
       (@e incoming_fc_window_size plus what we have sent, i.e. nothing).
       Starting at zero instead means a link that is up, validated and
       working carries nothing at all until an FC round trip completes --
       and if the peer cannot answer, not ever. */
    vl->outbound_fc_window_size = DEFAULT_WINDOW_SIZE;
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_put (
                    links,
                    &vl->target,
                    vl,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    vl->n = n;
    n->vl = vl;
    q->idle = GNUNET_YES;
    vl->visibility_task =
      GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
    consider_sending_fc (vl);
    /* We lacked a confirmed connection to the target
       before, so tell CORE about it (finally!) */
    cores_send_connect_info (&n->pid);
    send_msg_from_cache (vl);
  }
  else
  {
    /* Link was already up, remember n is also now available and we are done */
    if (NULL == vl->n)
    {
      vl->n = n;
      n->vl = vl;
      if (GNUNET_YES == vl->confirmed)
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Virtual link to %s could now also use direct neighbour!\n",
                    GNUNET_i2s (&vs->pid));
    }
    else
    {
      GNUNET_assert (n == vl->n);
    }
    if (GNUNET_NO == vl->confirmed)
    {
      vl->confirmed = GNUNET_YES;
      q->idle = GNUNET_YES;
      vl->visibility_task =
        GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
      consider_sending_fc (vl);
      /* We lacked a confirmed connection to the target
         before, so tell CORE about it (finally!) */
      cores_send_connect_info (&n->pid);
      send_msg_from_cache (vl);
    }
  }
}
 
 
static void
handle_incoming_msg (void *cls,
                     const struct GNUNET_TRANSPORT_IncomingMessage *im)
{
  struct TransportClient *tc = cls;
  struct Neighbour *n;
  struct CommunicatorMessageContext *cmc =
    GNUNET_new (struct CommunicatorMessageContext);
 
  cmc->tc = tc;
  cmc->im = *im;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received message with size %u and flow control id %" PRIu64
              " via communicator from peer %s\n",
              ntohs (im->header.size),
              im->fc_id,
              GNUNET_i2s (&im->sender));
  cmc->im.neighbour_sender = cmc->im.sender;
  /* A communicator got this straight from @a im->sender, so the queues to
     that neighbour demonstrably still work.  This is what #check_link_down()
     uses to bound how long a communicator that stopped working (without
     telling us) can keep a virtual link -- and CORE -- fooled. */
  if (NULL != (n = lookup_neighbour (&im->sender)))
    n->last_inbound = GNUNET_TIME_absolute_get ();
  cmc->mh = (const struct GNUNET_MessageHeader *) &im[1];
  demultiplex_with_cmc (cmc);
}
 
 
static int
check_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
{
  unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
  uint16_t msize = ntohs (fc->header.size);
  const char *tgnas;
  size_t avail;
  size_t off;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Flow control header size %u size of addresses %u number of addresses %u size of message struct %lu second struct %lu\n",
              ntohs (fc->header.size),
              ntohl (fc->size_of_addresses),
              ntohl (fc->number_of_addresses),
              sizeof(struct TransportFlowControlMessage),
              sizeof (struct TransportGlobalNattedAddress));
  if (0 == number_of_addresses)
    return GNUNET_OK;
  if (msize < sizeof(struct TransportFlowControlMessage))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  avail = msize - sizeof(struct TransportFlowControlMessage);
  tgnas = (const char *) &fc[1];
  off = 0;
  /* Validate EVERY entry: checking only the aggregate size lets a single
     entry claim a bogus address_length and send #handle_flow_control()
     out of bounds. */
  for (unsigned int i = 0; i < number_of_addresses; i++)
  {
    const struct TransportGlobalNattedAddress *tgna;
    size_t alen;
 
    if (avail - off < sizeof(struct TransportGlobalNattedAddress))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    tgna = (const struct TransportGlobalNattedAddress *) &tgnas[off];
    off += sizeof(struct TransportGlobalNattedAddress);
    alen = ntohl (tgna->address_length);
    if (avail - off < alen)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    off += alen;
  }
  return GNUNET_OK;
}
 
 
static struct GNUNET_TIME_Relative
calculate_rtt (struct DistanceVector *dv)
{
  struct GNUNET_TIME_Relative ret = GNUNET_TIME_UNIT_ZERO;
  unsigned int n_hops = 0;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "calculate_rtt\n");
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "calculate_rtt %lu\n",
                (unsigned long) pos->pd.aged_rtt.rel_value_us);
    n_hops++;
    ret = GNUNET_TIME_relative_add (GNUNET_TIME_relative_multiply (pos->pd.
                                                                   aged_rtt, pos
                                                                   ->distance
                                                                   + 2), ret);
  }
 
  if (0 == n_hops)
    return GNUNET_TIME_UNIT_FOREVER_REL;
  return ret;
}
 
 
static void
iterate_address_start_burst (void *cls,
                             const struct GNUNET_PeerIdentity *pid,
                             const char *uri)
{
  struct VirtualLink *vl = cls;
  const char *slash;
  char *address_uri;
  char *prefix;
  char *uri_without_port;
 
  slash = strrchr (uri, '/');
  if ((NULL == slash) || (slash - uri < 2))
  {
    GNUNET_break_op (0);   /* @a uri comes from a remote HELLO */
    return;
  }
  prefix = GNUNET_strndup (uri, (slash - uri) - 2);
  slash++;
  GNUNET_asprintf (&address_uri,
                   "%s-%s",
                   prefix,
                   slash);
 
  uri_without_port = get_address_without_port (address_uri);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "iterate_address_start_burst %s %s %s %s\n",
              (NULL == uri_without_port) ? "<unparsable>" : uri_without_port,
              uri,
              address_uri,
              slash);
  GNUNET_free (vl->burst_addr);
  if ((NULL != uri_without_port) &&
      (0 == strcmp (uri_without_port, slash)))
    vl->burst_addr = GNUNET_strdup (uri_without_port);
 
  GNUNET_free (prefix);
  GNUNET_free (address_uri);
  GNUNET_free (uri_without_port);
}
 
 
static void
check_for_burst_address (void *cls,
                         const struct GNUNET_PEERSTORE_Record *record,
                         const char *emsg)
{
  struct GNUNET_StartBurstCls *sb_cls = cls;
  struct VirtualLink *vl = sb_cls->vl;
  const struct GNUNET_MessageHeader *hello;
  struct GNUNET_HELLO_Parser *parser;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    /* @a emsg comes with a NULL record, which means the iteration is over
       and PEERSTORE is releasing the context itself -- stopping it here as
       well would free it twice.  Just drop our handle. */
    vl->ic = NULL;
    free_burst_cls (sb_cls);
    return;
  }
  if (NULL == record)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Hello iteration end for %s\n",
                GNUNET_i2s (&vl->target));
    /* PEERSTORE destroys the context itself once it signals the end. */
    vl->ic = NULL;
    free_burst_cls (sb_cls);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "check_for_burst_address\n");
  /* @a hello was published by a remote peer, it may well be malformed. */
  hello = hello_from_record (record);
  if (NULL != hello)
  {
    parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
    if (NULL != parser)
    {
      GNUNET_HELLO_parser_iterate (parser,
                                   &iterate_address_start_burst,
                                   vl);
      GNUNET_HELLO_parser_free (parser);
    }
  }
 
  /* MUST clear @e ic: #GNUNET_PEERSTORE_iteration_stop() frees it, and
     #free_virtual_link() would otherwise stop it a second time. */
  if (NULL != vl->ic)
  {
    GNUNET_PEERSTORE_iteration_stop (vl->ic);
    vl->ic = NULL;
  }
  free_burst_cls (sb_cls);
}
 
 
static void
burst_timeout (void *cls)
{
  burst_running = GNUNET_NO;
}
 
 
static void
start_burst (void *cls)
{
  struct GNUNET_StartBurstCls *sb_cls = cls;
  struct VirtualLink *vl = sb_cls->vl;
  struct GNUNET_TRANSPORT_StartBurst *sb;
  struct GNUNET_MQ_Envelope *env;
  char *uri_without_port = vl->burst_addr;
 
  burst_task = NULL;
  burst_task_cls = NULL;
  if (NULL == uri_without_port)
  {
    /* Lost the address in the meantime, nothing to burst to. */
    free_burst_cls (sb_cls);
    return;
  }
  /*char buf[strlen (uri_without_port) + 1];
 
  GNUNET_memcpy (buf, uri_without_port,  strlen (uri_without_port));
  buf[strlen (uri_without_port)] = '\0';*/
  env =
    GNUNET_MQ_msg_extra (sb,
                         strlen (uri_without_port) + 1,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST);
  sb->rtt = GNUNET_TIME_relative_hton (sb_cls->rtt);
  sb->pid = vl->target;
  memcpy (&sb[1], uri_without_port, strlen (uri_without_port) + 1);
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_COMMUNICATOR != tc->type)
      continue;   /* MUST come first: the log below reads the union! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "iterate_address_start_burst client tc prefix %s\n",
                tc->details.communicator.address_prefix);
    if (GNUNET_YES == tc->details.communicator.can_burst)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "iterate_address_start_burst %s call %lu %u rtt %lu\n",
                  uri_without_port,
                  strlen (uri_without_port),
                  ntohs (sb->header.size),
                  (unsigned long) sb_cls->rtt.rel_value_us);
      GNUNET_MQ_send (tc->mq, env);
      env = NULL;   /* MQ took ownership */
      burst_running = GNUNET_YES;
      burst_timeout_task = GNUNET_SCHEDULER_add_delayed (
        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                       60),
        &burst_timeout,
        NULL);
      // TODO We need some algo to choose from available communicators. Can we run two bursts at once? Atm we only implemented udp burst.
      break;
    }
  }
  if (NULL != env)
    GNUNET_MQ_discard (env);
  free_burst_cls (sb_cls);
}
 
 
static void
free_burst_cls (struct GNUNET_StartBurstCls *sb_cls)
{
  struct VirtualLink *vl = sb_cls->vl;
 
  if (burst_task_cls == sb_cls)
  {
    if (NULL != burst_task)
    {
      GNUNET_SCHEDULER_cancel (burst_task);
      burst_task = NULL;
    }
    burst_task_cls = NULL;
  }
  if ((NULL != vl) && (vl->sb_cls == sb_cls))
    vl->sb_cls = NULL;
  GNUNET_free (sb_cls);
}
 
 
static void
queue_burst (void *cls)
{
  struct GNUNET_StartBurstCls *sb_cls = cls;
  struct VirtualLink *vl = sb_cls->vl;
 
  if (GNUNET_YES != use_burst)
  {
    /* MUST release: nobody else owns @a sb_cls, and #handle_flow_control()
       allocates one for every FLOW_CONTROL message we receive. */
    free_burst_cls (sb_cls);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "burst_task %p ready %s burst addr %s (%p)\n",
              burst_task,
              sb_cls->sync_ready ? "yes" : "no",
              vl->burst_addr,
              vl->burst_addr);
  if (NULL != burst_task && GNUNET_NO == sb_cls->sync_ready)
  {
    /* Cancel the pending burst.  Both closures (the scheduled task's and
       ours) are ours to release. */
    struct GNUNET_StartBurstCls *pending = burst_task_cls;
 
    GNUNET_SCHEDULER_cancel (burst_task);
    burst_task = NULL;
    burst_task_cls = NULL;
    if ((NULL != pending) && (pending != sb_cls))
      free_burst_cls (pending);
    free_burst_cls (sb_cls);
    return;
  }
  if (GNUNET_NO == burst_running && NULL != vl->burst_addr && NULL == burst_task
      )
  {
    burst_task = GNUNET_SCHEDULER_add_delayed (sb_cls->delay,
                                               &start_burst,
                                               sb_cls);
    burst_task_cls = sb_cls;
  }
  else if (NULL == vl->burst_addr)
  {
    if (NULL != vl->ic)
    {
      /* An address lookup is already running for this link; starting a
         second one would leak the first. */
      free_burst_cls (sb_cls);
      return;
    }
    vl->ic = GNUNET_PEERSTORE_iteration_start (peerstore,
                                               "peerstore",
                                               &vl->target,
                                               GNUNET_PEERSTORE_HELLO_KEY,
                                               check_for_burst_address,
                                               sb_cls);
  }
  else
  {
    /* A burst is already running or already scheduled; we have no use for
       this closure. */
    free_burst_cls (sb_cls);
  }
}
 
 
static void
unconfirmed_link_timeout (void *cls)
{
  struct VirtualLink *vl = cls;
 
  vl->unconfirmed_timeout_task = NULL;
  if ((GNUNET_YES == vl->confirmed) ||
      (NULL != vl->n) ||
      (NULL != vl->dv))
    return;   /* got promoted in the meantime, its owner will clean up */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Discarding unconfirmed virtual link to %s\n",
              GNUNET_i2s (&vl->target));
  GNUNET_STATISTICS_update (GST_stats,
                            "# Unconfirmed virtual links timed out",
                            1,
                            GNUNET_NO);
  free_virtual_link (vl);
}
 
 
static void
handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
{
  struct CommunicatorMessageContext *cmc = cls;
  struct VirtualLink *vl;
  struct GNUNET_TIME_Absolute q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  uint32_t seq;
  struct GNUNET_TIME_Absolute st;
  uint64_t os;
  uint64_t wnd;
  uint32_t random;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received FC from %s\n", GNUNET_i2s (&cmc->im.sender));
  vl = lookup_virtual_link (&cmc->im.sender);
  if (NULL == vl)
  {
    vl = GNUNET_new (struct VirtualLink);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No virtual link for %p FC creating new unconfirmed virtual link to %s!\n",
                vl,
                GNUNET_i2s (&cmc->im.sender));
    vl->burst_addr = NULL;
    vl->confirmed = GNUNET_NO;
    vl->message_uuid_ctr =
      GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    vl->target = cmc->im.sender;
    vl->core_recv_window = RECV_WINDOW_SIZE;
    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
    /* What the peer will grant us in its very first FLOW_CONTROL anyway
       (@e incoming_fc_window_size plus what we have sent, i.e. nothing).
       Starting at zero instead means a link that is up, validated and
       working carries nothing at all until an FC round trip completes --
       and if the peer cannot answer, not ever. */
    vl->outbound_fc_window_size = DEFAULT_WINDOW_SIZE;
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_put (
                    links,
                    &vl->target,
                    vl,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    /* Nothing else owns this link yet, so it must reap itself if it never
       becomes confirmed -- otherwise any peer can make us allocate
       VirtualLinks without bound. */
    vl->unconfirmed_timeout_task =
      GNUNET_SCHEDULER_add_delayed (UNCONFIRMED_LINK_TIMEOUT,
                                    &unconfirmed_link_timeout,
                                    vl);
  }
  if (GNUNET_YES != vl->confirmed)
  {
    /* The peer flow-controls us, so it has a confirmed link to us -- but an
       unconfirmed link carries nothing and is never reported to CORE.  Only
       #handle_validation_response() breaks that tie, and nothing here used
       to ask for one, so the pair could sit one-way until the peer's own
       four hour revalidation came round. */
    try_to_bring_link_up (&cmc->im.sender);
  }
  if (NULL != vl->n)
  {
    for (struct Queue *q = vl->n->queue_head; NULL != q; q = q->next_neighbour)
      q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "remaining %lu timeout for neighbour %p\n",
              (unsigned long) GNUNET_TIME_absolute_get_remaining (q_timeout).
              rel_value_us,
              vl->n);
  if (NULL == vl->n ||
      0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
  {
    struct GNUNET_TIME_Relative rtt;
    struct GNUNET_BurstSync burst_sync;
    struct GNUNET_StartBurstCls *bcls;
 
    if (NULL != vl->sb_cls)
    {
      /* A burst attempt for this link is already in flight.  Allocating a
         second closure would orphan the first one: @e sb_cls is how
         #free_virtual_link() finds (and cancels) the pending #burst_task,
         and a peer that just keeps sending us FLOW_CONTROL messages would
         otherwise make us leak one closure per message. */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Burst attempt to %s already pending\n",
                  GNUNET_i2s (&vl->target));
    }
    else
    {
      bcls = GNUNET_new (struct GNUNET_StartBurstCls);
      bcls->vl = vl;
      vl->sb_cls = bcls;
      if (NULL != vl->dv)
        rtt = calculate_rtt (vl->dv);
      else
        rtt = GNUNET_TIME_UNIT_FOREVER_REL;
      burst_sync.rtt_average = fc->rtt;
      bcls->rtt = GNUNET_TIME_relative_ntoh (burst_sync.rtt_average);
      /* @e sync_ready of `struct GNUNET_BurstSync' is a host-order enum. */
      burst_sync.sync_ready =
        (enum GNUNET_GenericReturnValue) ntohl (fc->sync_ready);
 
      /* NOTE: #GNUNET_is_burst_ready() does NOT invoke the task unless both
         RTT estimates are known and close; #queue_burst() is thus not
         guaranteed to run, which is why @e sb_cls stays owned by @a vl. */
      GNUNET_is_burst_ready (rtt,
                             &burst_sync,
                             &queue_burst,
                             bcls);
    }
  }
  if (0 != ntohl (fc->number_of_addresses))
  {
    unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
    const char *tgnas;
    unsigned int off = 0;
 
    tgnas = (const char *) &fc[1];
 
    for (unsigned int i = 0; i < number_of_addresses; i++)
    {
      struct TransportGlobalNattedAddress *tgna;
      char *addr;
      uint32_t address_length;
 
      tgna = (struct TransportGlobalNattedAddress*) &tgnas[off];
      addr = (char *) &tgna[1];
      address_length = ntohl (tgna->address_length);
      off += sizeof(struct TransportGlobalNattedAddress) + address_length;
 
      /* NOTE: the address is NOT 0-terminated (it comes straight off the
         wire), it must be printed with an explicit precision. */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "received address %.*s length %u\n",
                  (int) address_length,
                  addr,
                  address_length);
 
      if (NULL != nh)
        GNUNET_NAT_add_global_address (nh, addr, ntohl (tgna->address_length));
    }
  }
  st = GNUNET_TIME_absolute_ntoh (fc->sender_time);
  if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "FC dropped: Message out of order\n");
    /* out of order, drop */
    GNUNET_STATISTICS_update (GST_stats,
                              "# FC dropped: message out of order",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  seq = ntohl (fc->seq);
  if (seq < vl->last_fc_seq)
  {
    /* Wrap-around/reset of other peer; start all counters from zero */
    vl->outbound_fc_window_size_used = 0;
  }
  vl->last_fc_seq = seq;
  vl->last_fc_timestamp = st;
  /* The peer is answering, so the backoff in #consider_sending_fc() starts
     over: @e fc_retransmit_count counts *unanswered* rounds. */
  vl->fc_retransmit_count = 0;
  vl->outbound_fc_window_size = GNUNET_ntohll (fc->inbound_window_size);
  os = GNUNET_ntohll (fc->outbound_sent);
  vl->incoming_fc_window_size_loss =
    (int64_t) (os - vl->incoming_fc_window_size_used);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received FC from %s, seq %u, new window %llu (loss at %lld)\n",
              GNUNET_i2s (&vl->target),
              (unsigned int) seq,
              (unsigned long long) vl->outbound_fc_window_size,
              (long long) vl->incoming_fc_window_size_loss);
  wnd = GNUNET_ntohll (fc->outbound_window_size);
  random = GNUNET_CRYPTO_random_u32 (UINT32_MAX);
  /* NOTE: this must NOT be restricted to a confirmed link.  @e
     outbound_fc_window_size starts at zero and is raised *only* here, from
     the peer's FC.  So a peer whose link to us is confirmed while ours to it
     is not cannot send us a single byte until we answer -- and it is exactly
     that peer that keeps asking.  Staying quiet deadlocks the pair: it shows
     an established virtual link with messages pending forever, we show none,
     and CORE never completes its handshake in either direction. */
  if ((wnd < vl->incoming_fc_window_size
       + vl->incoming_fc_window_size_used
       + vl->incoming_fc_window_size_loss) ||
      (vl->last_outbound_window_size_received != wnd) ||
      (0 == random % FC_NO_CHANGE_REPLY_PROBABILITY))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "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",
                (unsigned long long) wnd,
                (unsigned long long) vl->incoming_fc_window_size,
                (unsigned long long) vl->last_outbound_window_size_received,
                random % FC_NO_CHANGE_REPLY_PROBABILITY);
    consider_sending_fc (vl);
  }
  if ((wnd == vl->incoming_fc_window_size
       + vl->incoming_fc_window_size_used
       + vl->incoming_fc_window_size_loss) &&
      (vl->last_outbound_window_size_received == wnd))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Slowing FC transmission to %s to keepalive rate: peer is current at window %llu\n",
                GNUNET_i2s (&vl->target),
                (unsigned long long) wnd);
    /* NOTE: this used to also require @e fc_retransmit_task to be non-NULL
       and did nothing at all otherwise -- so a link whose chain had ended
       (see #consider_sending_fc()) could never pick the keepalive back up,
       even though the peer was demonstrably still talking to us. */
    if (NULL != vl->fc_retransmit_task)
      GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
    vl->fc_retransmit_count = 0;
    /* Drop to the keepalive rate rather than stopping outright.  There is
       nothing left to retransmit -- but if we go completely quiet, and the
       peer does the same for the same reason, then neither end sees any
       traffic and #check_link_down() tears down a perfectly healthy link
       after #NEIGHBOUR_LIVENESS_TIMEOUT.  One tiny FC message every
       #FC_KEEPALIVE_INTERVAL is what keeps @e last_inbound moving on the
       other side (and, via their reply, on ours). */
    vl->fc_retransmit_task =
      GNUNET_SCHEDULER_add_delayed (FC_KEEPALIVE_INTERVAL,
                                    &task_consider_sending_fc,
                                    vl);
  }
  vl->last_outbound_window_size_received = wnd;
  /* FC window likely increased, check transmission possibilities! */
  check_vl_transmission (vl);
  finish_cmc_handling (cmc);
}
 
 
static void
demultiplex_with_cmc (struct CommunicatorMessageContext *cmc)
{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (fragment_box,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT,
                           struct TransportFragmentBoxMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (reliability_box,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX,
                           struct TransportReliabilityBoxMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (reliability_ack,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK,
                           struct TransportReliabilityAckMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (backchannel_encapsulation,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION,
                           struct TransportBackchannelEncapsulationMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (dv_learn,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN,
                           struct TransportDVLearnMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (dv_box,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX,
                           struct TransportDVBoxMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (flow_control,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL,
                           struct TransportFlowControlMessage,
                           cmc),
    GNUNET_MQ_hd_fixed_size (
      validation_challenge,
      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE,
      struct TransportValidationChallengeMessage,
      cmc),
    GNUNET_MQ_hd_fixed_size (
      validation_response,
      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE,
      struct TransportValidationResponseMessage,
      cmc),
    GNUNET_MQ_handler_end () };
  int ret;
  const struct GNUNET_MessageHeader *msg = cmc->mh;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling message of type %u with %u bytes\n",
              (unsigned int) ntohs (msg->type),
              (unsigned int) ntohs (msg->size));
  /* @a handlers only covers the encapsulations *we* add; anything else is a
     payload for CORE and leaves through #handle_raw_message() below. So
     #GNUNET_NO is the common case here -- one per delivered CORE message --
     and not something to log about, which is why this is the "try" variant. */
  ret = GNUNET_MQ_try_handle_message (handlers, msg);
  if (GNUNET_SYSERR == ret)
  {
    /* @a msg is the message a *remote peer* sent us: #handle_incoming_msg()
       points @e mh into the payload of the
       #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG the communicator
       delivered, and every other caller unwraps it from remote traffic as
       well.  So failing a check here is that peer's protocol violation, and
       it says nothing at all about the communicator that carried it.
 
       Dropping the client therefore punishes the wrong party, and it
       punishes it hard: #GNUNET_SERVICE_client_drop() disconnects the
       communicator *process*, which takes down every queue it owns and thus
       every neighbour reachable through it.  One malformed DV box on a
       shared UDP communicator disconnects every peer we have on it, CORE
       tears the sessions down, and the key exchanges that would rebuild
       them have to wait for the communicator to come back and revalidate.
       Since the offending bytes arrive from the network, any peer can do
       this to us at will, repeatedly.
 
       Drop the message and keep the communicator: resume it exactly as the
       success path does, so it still gets its flow-control ACK and its
       GNUNET_SERVICE_client_continue(). */
    GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              "# malformed messages discarded",
                              1,
                              GNUNET_NO);
    finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  if (GNUNET_NO == ret)
  {
    /* unencapsulated 'raw' message */
    handle_raw_message (cmc, msg);
  }
}
 
 
static int
check_add_queue_message (void *cls,
                         const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_MQ_check_zero_termination (aqm);
  return GNUNET_OK;
}
 
 
static void
set_pending_message_uuid (struct PendingMessage *pm)
{
  if (pm->msg_uuid_set)
    return;
  pm->msg_uuid.uuid = pm->vl->message_uuid_ctr++;
  pm->msg_uuid_set = GNUNET_YES;
}
 
 
static struct PendingAcknowledgement *
prepare_pending_acknowledgement (struct Queue *queue,
                                 struct DistanceVectorHop *dvh,
                                 struct PendingMessage *pm)
{
  struct PendingAcknowledgement *pa;
 
  pa = GNUNET_new (struct PendingAcknowledgement);
  pa->queue = queue;
  pa->dvh = dvh;
  pa->pm = pm;
  do
  {
    GNUNET_CRYPTO_random_block (&pa->ack_uuid,
                                sizeof(pa->ack_uuid));
  }
  while (GNUNET_YES != GNUNET_CONTAINER_multiuuidmap_put (
           pending_acks,
           &pa->ack_uuid.value,
           pa,
           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  GNUNET_CONTAINER_MDLL_insert (queue, queue->pa_head, queue->pa_tail, pa);
  GNUNET_CONTAINER_MDLL_insert (pm, pm->pa_head, pm->pa_tail, pa);
  if (NULL != dvh)
    GNUNET_CONTAINER_MDLL_insert (dvh, dvh->pa_head, dvh->pa_tail, pa);
  pa->transmission_time = GNUNET_TIME_absolute_get ();
  pa->message_size = pm->bytes_msg;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Waiting for ACKnowledgment `%s' for <%" PRIu64 ">\n",
              GNUNET_uuid2s (&pa->ack_uuid.value),
              pm->logging_uuid);
  return pa;
}
 
 
static struct PendingMessage *
fragment_message (struct Queue *queue,
                  struct DistanceVectorHop *dvh,
                  struct PendingMessage *pm)
{
  struct PendingAcknowledgement *pa;
  struct PendingMessage *ff;
  uint16_t mtu;
  uint16_t msize;
 
  mtu = (UINT16_MAX == queue->mtu)
        ? UINT16_MAX - sizeof(struct GNUNET_TRANSPORT_SendMessageTo)
        : queue->mtu;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Fragmenting message <%" PRIu64
              "> with size %u to %s for MTU %u\n",
              pm->logging_uuid,
              pm->bytes_msg,
              GNUNET_i2s (&pm->vl->target),
              (unsigned int) mtu);
  set_pending_message_uuid (pm);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Fragmenting message %" PRIu64 " <%" PRIu64
              "> with size %u to %s for MTU %u\n",
              pm->msg_uuid.uuid,
              pm->logging_uuid,
              pm->bytes_msg,
              GNUNET_i2s (&pm->vl->target),
              (unsigned int) mtu);
 
  /* This invariant is established in #handle_add_queue_message() */
  GNUNET_assert (mtu > sizeof(struct TransportFragmentBoxMessage));
 
  /* select fragment for transmission, descending the tree if it has
     been expanded until we are at a leaf or at a fragment that is small
     enough
   */
  ff = pm;
  msize = ff->bytes_msg;
 
  while (((ff->bytes_msg > mtu) || (pm == ff)) &&
         (ff->frag_off == msize) && (NULL != ff->head_frag))
  {
    ff = ff->head_frag;   /* descent into fragmented fragments */
    msize = ff->bytes_msg - sizeof(struct TransportFragmentBoxMessage);
  }
 
  if (((ff->bytes_msg > mtu) || (pm == ff)) && (ff->frag_off < msize))
  {
    /* Did not yet calculate all fragments, calculate next fragment */
    struct PendingMessage *frag;
    struct TransportFragmentBoxMessage tfb;
    const char *orig;
    char *msg;
    uint16_t fragmax;
    uint16_t fragsize;
    uint16_t msize_ff;
    uint16_t xoff = 0;
    pm->frag_count++;
 
    orig = (const char *) &ff[1];
    msize_ff = ff->bytes_msg;
    if (pm != ff)
    {
      const struct TransportFragmentBoxMessage *tfbo;
 
      tfbo = (const struct TransportFragmentBoxMessage *) orig;
      orig += sizeof(struct TransportFragmentBoxMessage);
      msize_ff -= sizeof(struct TransportFragmentBoxMessage);
      xoff = ntohs (tfbo->frag_off);
    }
    fragmax = mtu - sizeof(struct TransportFragmentBoxMessage);
    fragsize = GNUNET_MIN (msize_ff - ff->frag_off, fragmax);
    frag =
      GNUNET_malloc (sizeof(struct PendingMessage)
                     + sizeof(struct TransportFragmentBoxMessage) + fragsize);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "3 created pm %p from pm %p storing vl %p from pm %p\n",
                frag,
                ff,
                pm->vl,
                pm);
    frag->logging_uuid = logging_uuid_gen++;
    frag->vl = pm->vl;
    frag->frag_parent = ff;
    frag->timeout = pm->timeout;
    frag->bytes_msg = sizeof(struct TransportFragmentBoxMessage) + fragsize;
    frag->pmt = PMT_FRAGMENT_BOX;
    msg = (char *) &frag[1];
    tfb.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT);
    tfb.header.size =
      htons (sizeof(struct TransportFragmentBoxMessage) + fragsize);
    pa = prepare_pending_acknowledgement (queue, dvh, frag);
    tfb.ack_uuid = pa->ack_uuid;
    tfb.msg_uuid = pm->msg_uuid;
    tfb.frag_off = htons (ff->frag_off + xoff);
    tfb.msg_size = htons (pm->bytes_msg);
    memcpy (msg, &tfb, sizeof(tfb));
    memcpy (&msg[sizeof(tfb)], &orig[ff->frag_off], fragsize);
    GNUNET_CONTAINER_MDLL_insert (frag, ff->head_frag,
                                  ff->tail_frag, frag);
    ff->frag_off += fragsize;
    ff = frag;
  }
 
  if (pm == ff)
  {
    /* Neither the descent nor the branch above moved us off @a pm, so there
       is no fragment to send: @e head_frag is empty *and* @e frag_off says
       everything was already cut.  completed_pending_message() leaves
       exactly that state behind when the last outstanding fragment is
       acknowledged but its condition for finishing the root does not hold
       (@e frag_off having been advanced past the boxed payload size, or the
       root being a reliability box).  The rotate below then dereferences
       @e frag_parent, which is NULL for the message on @e pending_msg_head.
 
       Report "nothing to fragment" instead; the caller reschedules. */
    GNUNET_break (0);
    return NULL;
  }
  /* Move head to the tail and return it */
  GNUNET_CONTAINER_MDLL_remove (frag,
                                ff->frag_parent->head_frag,
                                ff->frag_parent->tail_frag,
                                ff);
  GNUNET_CONTAINER_MDLL_insert_tail (frag,
                                     ff->frag_parent->head_frag,
                                     ff->frag_parent->tail_frag,
                                     ff);
 
  return ff;
}
 
 
static struct PendingMessage *
reliability_box_message (struct Queue *queue,
                         struct DistanceVectorHop *dvh,
                         struct PendingMessage *pm)
{
  struct TransportReliabilityBoxMessage rbox;
  struct PendingAcknowledgement *pa;
  struct PendingMessage *bpm;
  char *msg;
 
  if ((PMT_CORE != pm->pmt) && (PMT_DV_BOX != pm->pmt))
    return pm; /* already fragmented or reliability boxed, or control message:
                  do nothing */
  if (NULL != pm->bpm)
    return pm->bpm; /* already computed earlier: do nothing */
  // TODO I guess we do not need this assertion. We might have a DLL with
  // fragments, because the MTU changed, and we do not need to fragment anymore.
  // But we should keep the fragments until message was completed, because
  // the MTU might change again.
  // GNUNET_assert (NULL == pm->head_frag);
  if (pm->bytes_msg + sizeof(rbox) > UINT16_MAX)
  {
    /* failed hard */
    GNUNET_break (0);
    client_send_response (pm);
    return NULL;
  }
 
  pa = prepare_pending_acknowledgement (queue, dvh, pm);
 
  bpm = GNUNET_malloc (sizeof(struct PendingMessage) + sizeof(rbox)
                       + pm->bytes_msg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "4 created pm %p storing vl %p from pm %p\n",
              bpm,
              pm->vl,
              pm);
  bpm->logging_uuid = logging_uuid_gen++;
  bpm->vl = pm->vl;
  bpm->frag_parent = pm;
  // Why was this needed?
  // GNUNET_CONTAINER_MDLL_insert (frag, pm->head_frag, pm->tail_frag, bpm);
  bpm->timeout = pm->timeout;
  bpm->pmt = PMT_RELIABILITY_BOX;
  bpm->bytes_msg = pm->bytes_msg + sizeof(rbox);
  set_pending_message_uuid (bpm);
  rbox.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX);
  rbox.header.size = htons (sizeof(rbox) + pm->bytes_msg);
  rbox.ack_countdown = htonl (0);  // FIXME: implement ACK countdown support
 
  rbox.ack_uuid = pa->ack_uuid;
  msg = (char *) &bpm[1];
  memcpy (msg, &rbox, sizeof(rbox));
  memcpy (&msg[sizeof(rbox)], &pm[1], pm->bytes_msg);
  pm->bpm = bpm;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Preparing reliability box for message <%" PRIu64
              "> of size %d (%d) to %s on queue %s\n",
              pm->logging_uuid,
              pm->bytes_msg,
              ntohs (((const struct GNUNET_MessageHeader *) &pm[1])->size),
              GNUNET_i2s (&pm->vl->target),
              queue->address);
  return bpm;
}
 
 
static void
reorder_root_pm (struct PendingMessage *pm,
                 struct GNUNET_TIME_Absolute next_attempt)
{
  struct VirtualLink *vl = pm->vl;
  struct PendingMessage *pos;
 
  /* Only a message without a parent is on vl->pending_msg_head; anything
     else is not ours to reorder and MDLL_remove() would abort on it. */
  if ((NULL == vl) ||
      (NULL != pm->frag_parent) ||
      ((NULL == pm->prev_vl) && (vl->pending_msg_head != pm)))
  {
    GNUNET_break (0);
    return;
  }
  /* re-insert sort in neighbour list */
  GNUNET_CONTAINER_MDLL_remove (vl,
                                vl->pending_msg_head,
                                vl->pending_msg_tail,
                                pm);
  pos = vl->pending_msg_tail;
  while ((NULL != pos) &&
         (next_attempt.abs_value_us > pos->next_attempt.abs_value_us))
    pos = pos->prev_vl;
  GNUNET_CONTAINER_MDLL_insert_after (vl,
                                      vl->pending_msg_head,
                                      vl->pending_msg_tail,
                                      pos,
                                      pm);
}
 
 
static unsigned int
check_next_attempt_tree (struct PendingMessage *pm, struct PendingMessage *root)
{
  struct PendingMessage *pos;
  /* MUST be initialised: for a leaf the loop below never runs */
  enum GNUNET_GenericReturnValue frags_in_flight = GNUNET_NO;
 
  pos = pm->head_frag;
  while (NULL != pos)
  {
    if (pos->frags_in_flight_round == pm->frags_in_flight_round ||
        GNUNET_NO == check_next_attempt_tree (pos, root))
      frags_in_flight = GNUNET_NO;
    else
    {
      frags_in_flight = GNUNET_YES;
      break;
    }
    pos = pos->next_frag;
  }
 
  return frags_in_flight;
}
 
 
static void
harmonize_flight_round (struct PendingMessage *pm)
{
  struct PendingMessage *pos;
 
  pos = pm->head_frag;
  while (NULL != pos)
  {
    pos->frags_in_flight_round = pm->frags_in_flight_round;
    harmonize_flight_round (pos);
    pos = pos->next_frag;
  }
}
 
 
static void
update_pm_next_attempt (struct PendingMessage *pm,
                        struct GNUNET_TIME_Absolute next_attempt)
{
  if (NULL == pm->frag_parent)
  {
    pm->next_attempt = next_attempt;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Next attempt for message <%" PRIu64 "> set to %" PRIu64 "\n",
                pm->logging_uuid,
                next_attempt.abs_value_us);
    reorder_root_pm (pm, next_attempt);
  }
  else if ((PMT_RELIABILITY_BOX == pm->pmt) || (PMT_DV_BOX == pm->pmt))// || (PMT_FRAGMENT_BOX == pm->pmt))
  {
    struct PendingMessage *root = pm->frag_parent;
 
    while (NULL != root->frag_parent)
      root = root->frag_parent;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Next attempt for root message <%" PRIu64 "> set to %s\n",
                root->logging_uuid,
                GNUNET_STRINGS_absolute_time_to_string (next_attempt));
    root->next_attempt = next_attempt;
    reorder_root_pm (root, next_attempt);
  }
  else
  {
    struct PendingMessage *root = pm->frag_parent;
 
    while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
      root = root->frag_parent;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "frag_count next attempt %u\n",
                root->frag_count);
 
    if (GNUNET_NO == root->frags_in_flight)
    {
      root->next_attempt = next_attempt;
      harmonize_flight_round (root);
      root->frags_in_flight_round++;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Next attempt for fragmented message <%" PRIu64 "> (<%" PRIu64
                  ">)set to %" PRIu64 "\n",
                  pm->logging_uuid,
                  root->logging_uuid,
                  next_attempt.abs_value_us);
    }
 
    pm->next_attempt = root->next_attempt;
    pm->frags_in_flight_round = root->frags_in_flight_round;
    harmonize_flight_round (pm);
 
    if (root->bytes_msg == root->frag_off)
      root->frags_in_flight = check_next_attempt_tree (root, root);
    else
      root->frags_in_flight = GNUNET_YES;
 
    if (GNUNET_NO == root->frags_in_flight)
    {
      /* `root' deliberately stops at a DV box, which is itself a child of
         the message on vl->pending_msg_head.  Walk the rest of the way for
         the reorder: only the parentless message is on that list. */
      struct PendingMessage *vl_root = root;
 
      while (NULL != vl_root->frag_parent)
        vl_root = vl_root->frag_parent;
      vl_root->next_attempt = root->next_attempt;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "We have no fragments in flight for message %" PRIu64
                  ", reorder root %" PRIu64 "! Next attempt is %" PRIu64 "\n",
                  root->logging_uuid,
                  vl_root->logging_uuid,
                  vl_root->next_attempt.abs_value_us);
      reorder_root_pm (vl_root, vl_root->next_attempt);
    }
    else
    {
      double factor = ((double) root->frag_count - 1)
                      / (double) root->frag_count;
      struct GNUNET_TIME_Relative s1;
      struct GNUNET_TIME_Relative s2;
      struct GNUNET_TIME_Relative plus_mean =
        GNUNET_TIME_absolute_get_remaining (root->next_attempt);
      struct GNUNET_TIME_Relative plus = GNUNET_TIME_absolute_get_remaining (
        next_attempt);
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "frag_count %u after factor\n",
                  root->frag_count);
      s1 = GNUNET_TIME_relative_multiply_double (plus_mean,
                                                 factor);
      s2 = GNUNET_TIME_relative_divide (plus,
                                        root->frag_count);
      plus_mean = GNUNET_TIME_relative_add (s1, s2);
      root->next_attempt = GNUNET_TIME_relative_to_absolute (plus_mean);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "We have fragments in flight for message %" PRIu64
                  ", do not reorder root! Actual next attempt %" PRIu64 "\n",
                  root->logging_uuid,
                  root->next_attempt.abs_value_us);
    }
  }
}
 
 
struct PendingMessageScoreContext
{
  struct PendingMessage *best;
 
  struct DistanceVectorHop *dvh;
 
  size_t real_overhead;
 
  unsigned int consideration_counter;
 
  int frag;
 
  int relb;
 
  int to_early;
 
  unsigned int frags_in_flight;
 
  struct GNUNET_TIME_Relative to_early_retry_delay;
};
 
 
static void
select_best_pending_from_link (struct PendingMessageScoreContext *sc,
                               struct Queue *queue,
                               struct VirtualLink *vl,
                               struct DistanceVectorHop *dvh,
                               size_t overhead)
{
  struct GNUNET_TIME_Absolute now;
 
  now = GNUNET_TIME_absolute_get ();
  /* NOTE: @a sc accumulates across calls -- #transmit_on_queue() zeroes it
     once and then runs us for the direct link and for every DV hop in turn.
     Clearing the verdict here made each call discard what the previous ones
     found, so a message that was too early on the direct link was forgotten
     as soon as one DV hop had nothing to offer, and nothing rescheduled the
     queue at all. */
  for (struct PendingMessage *pos = vl->pending_msg_head; NULL != pos;
       pos = pos->next_vl)
  {
    size_t real_overhead = overhead;
    int frag;
    int relb;
 
    if ((NULL != dvh) && (PMT_DV_BOX == pos->pmt))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV messages must not be DV-routed to next hop!\n");
      continue;   /* DV messages must not be DV-routed to next hop! */
    }
    if (pos->next_attempt.abs_value_us > now.abs_value_us)
    {
      if (GNUNET_YES == pos->frags_in_flight)
      {
        sc->frags_in_flight = GNUNET_YES;
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Fragments in flight for message %" PRIu64 "\n",
                    pos->logging_uuid);
      }
      else
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Maybe too early, because message are sorted by next_attempt, if there are no fragments in flight.Checked message %"
                    PRIu64 "\n",
                    pos->logging_uuid);
        /* The *earliest* deadline is the one to come back for: @e
           pending_msg_head is sorted by @e next_attempt, so overwriting
           this on every iteration left the largest delay of the whole
           list -- the queue then slept past every message but the last
           one.  Across the calls for the direct link and each DV hop the
           same argument applies, hence the min() rather than an
           assignment. */
        sc->to_early_retry_delay =
          (GNUNET_YES == sc->to_early)
          ? GNUNET_TIME_relative_min (sc->to_early_retry_delay,
                                      GNUNET_TIME_absolute_get_remaining (
                                        pos->next_attempt))
          : GNUNET_TIME_absolute_get_remaining (pos->next_attempt);
        sc->to_early = GNUNET_YES;
        continue;
      }
      // break;   /* too early for all messages, they are sorted by next_attempt */
    }
    if (NULL != pos->qe)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "not eligible\n");
      continue;   /* not eligible */
    }
    sc->consideration_counter++;
    /* determine if we have to fragment, if so add fragmentation
       overhead! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "check %" PRIu64 " for sc->best\n",
                pos->logging_uuid);
    frag = GNUNET_NO;
    if (((0 != queue->mtu) &&
         (pos->bytes_msg + real_overhead > queue->mtu)) ||
        (pos->bytes_msg > UINT16_MAX - sizeof(struct
                                              GNUNET_TRANSPORT_SendMessageTo))
        ||
        (NULL != pos->head_frag /* fragments already exist, should
                                     respect that even if MTU is UINT16_MAX for
                                     this queue */))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "fragment msg with size %u, realoverhead is %lu\n",
                  pos->bytes_msg,
                  real_overhead);
      frag = GNUNET_YES;
      if (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc)
      {
        /* FIXME-FRAG-REL-UUID: we could use an optimized, shorter fragmentation
           header without the ACK UUID when using a *reliable* channel! */
      }
      real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
    }
    /* determine if we have to reliability-box, if so add reliability box
       overhead */
    relb = GNUNET_NO;
    if ((GNUNET_NO == frag) &&
        (0 == (pos->prefs & GNUNET_MQ_PREF_UNRELIABLE)) &&
        (GNUNET_TRANSPORT_CC_RELIABLE != queue->tc->details.communicator.cc))
    {
      real_overhead += sizeof(struct TransportReliabilityBoxMessage);
 
      if ((0 != queue->mtu) && (pos->bytes_msg + real_overhead > queue->mtu))
      {
        frag = GNUNET_YES;
        real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
      }
      else
      {
        relb = GNUNET_YES;
      }
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Create reliability box of msg with size %u, realoverhead is %lu %u %u %u\n",
                  pos->bytes_msg,
                  real_overhead,
                  queue->mtu,
                  frag,
                  relb);
    }
 
    /* Finally, compare to existing 'best' in sc to see if this 'pos' pending
       message would beat it! */
    if (GNUNET_NO == sc->frags_in_flight && NULL != sc->best)
    {
      /* CHECK if pos fits queue BETTER (=smaller) than pm, if not: continue;
         OPTIMIZE-ME: This is a heuristic, which so far has NOT been
         experimentally validated. There may be some huge potential for
         improvement here. Also, we right now only compare how well the
         given message fits _this_ queue, and do not consider how well other
         queues might suit the message. Taking other queues into consideration
         may further improve the result, but could also be expensive
         in terms of CPU time.  */
      long long sc_score = sc->frag * 40 + sc->relb * 20 + sc->real_overhead;
      long long pm_score = frag * 40 + relb * 20 + real_overhead;
      long long time_delta =
        (sc->best->next_attempt.abs_value_us - pos->next_attempt.abs_value_us)
        / 1000LL;
 
      /* "time_delta" considers which message has been 'ready' for transmission
         for longer, if a message has a preference for low latency, increase
         the weight of the time_delta by 10x if it is favorable for that message */
      if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
          (0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)))
        time_delta *= 10;     /* increase weight (always, both are low latency) */
      else if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
               (time_delta > 0))
        time_delta *= 10;     /* increase weight, favors 'pos', which is low latency */
      else if ((0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
               (time_delta < 0))
        time_delta *= 10;     /* increase weight, favors 'sc->best', which is low latency */
      if (0 != queue->mtu)
      {
        /* Grant bonus if we are below MTU, larger bonus the closer we will
           be to the MTU */
        if (queue->mtu > sc->real_overhead + sc->best->bytes_msg)
          sc_score -= queue->mtu - (sc->real_overhead + sc->best->bytes_msg);
        if (queue->mtu > real_overhead + pos->bytes_msg)
          pm_score -= queue->mtu - (real_overhead + pos->bytes_msg);
      }
      if (sc_score + time_delta > pm_score)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "sc_score of %" PRIu64 " larger, keep sc->best %" PRIu64
                    "\n",
                    pos->logging_uuid,
                    sc->best->logging_uuid);
        continue;     /* sc_score larger, keep sc->best */
      }
    }
    sc->best = pos;
    sc->dvh = dvh;
    sc->frag = frag;
    sc->relb = relb;
    sc->real_overhead = real_overhead;
  }
}
 
 
static void
extract_box_cb (void *cls,
                struct Neighbour *next_hop,
                const struct GNUNET_MessageHeader *hdr,
                enum RouteMessageOptions options)
{
  struct PendingMessageScoreContext *sc = cls;
  struct PendingMessage *pm = sc->best;
  struct PendingMessage *bpm;
  uint16_t bsize = ntohs (hdr->size);
 
  GNUNET_assert (NULL == pm->bpm);
  bpm = GNUNET_malloc (sizeof(struct PendingMessage) + bsize);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "5 created pm %p storing vl %p from pm %p\n",
              bpm,
              pm->vl,
              pm);
  bpm->logging_uuid = logging_uuid_gen++;
  bpm->pmt = PMT_DV_BOX;
  bpm->vl = pm->vl;
  bpm->timeout = pm->timeout;
  bpm->bytes_msg = bsize;
  bpm->frag_parent = pm;
  set_pending_message_uuid (bpm);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating DV Box %" PRIu64 " for original message %" PRIu64
              " (next hop is %s)\n",
              bpm->logging_uuid,
              pm->logging_uuid,
              GNUNET_i2s (&next_hop->pid));
  memcpy (&bpm[1], hdr, bsize);
  pm->bpm = bpm;
}
 
 
static void
transmit_on_queue (void *cls)
{
  struct Queue *queue = cls;
  struct Neighbour *n = queue->neighbour;
  struct PendingMessageScoreContext sc;
  struct PendingMessage *pm;
 
  queue->transmit_task = NULL;
  if ((NULL == n->vl) && (NULL == n->dv_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Virtual link `%s' is down, cannot have PM for queue `%s'\n",
                GNUNET_i2s (&n->pid),
                queue->address);
    queue->idle = GNUNET_YES;
    return;
  }
  memset (&sc, 0, sizeof(sc));
  /* @e n need not have a link of its own: it may serve only as the first
     hop of DV paths, and the traffic queued for those still has to go out. */
  if (NULL != n->vl)
    select_best_pending_from_link (&sc, queue, n->vl, NULL, 0);
  if (NULL == sc.best)
  {
    /* Also look at DVH that have the n as first hop! */
    for (struct DistanceVectorHop *dvh = n->dv_head; NULL != dvh;
         dvh = dvh->next_neighbour)
    {
      if (NULL == dvh->dv->vl)
        continue;   /* route not (yet) visible to CORE, no messages for it */
      select_best_pending_from_link (&sc,
                                     queue,
                                     dvh->dv->vl,
                                     dvh,
                                     sizeof(struct GNUNET_PeerIdentity)
                                     * (1 + dvh->distance)
                                     + sizeof(struct TransportDVBoxMessage)
                                     + sizeof(struct TransportDVBoxPayloadP));
    }
  }
  if (NULL == sc.best)
  {
    /* no message pending, nothing to do here! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No pending messages, queue `%s' to %s now idle\n",
                queue->address,
                GNUNET_i2s (&n->pid));
    if (GNUNET_YES == sc.to_early)
      schedule_transmit_on_queue (sc.to_early_retry_delay,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
    queue->idle = GNUNET_YES;
    return;
  }
  /* There is a message pending, we are certainly not idle */
  queue->idle = GNUNET_NO;
 
  /* Given selection in `sc`, do transmission */
  pm = sc.best;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Selected message <%" PRIu64 ">\n",
              pm->logging_uuid);
  if (NULL != sc.dvh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Is this %u a DV box?\n",
                pm->pmt);
    GNUNET_assert (PMT_DV_BOX != pm->pmt);
    if ((NULL != sc.best->bpm) && (sc.best->bpm->used_dvh != sc.dvh))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Discard old box, because we have a new DV path.\n");
      free_pending_message (sc.best->bpm);
      sc.best->bpm = NULL;
    }
 
    if (NULL == sc.best->bpm)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "encapsulate_for_dv 2\n");
      encapsulate_for_dv (sc.dvh->dv,
                          1,
                          &sc.dvh,
                          (const struct GNUNET_MessageHeader *) &sc.best[1],
                          &extract_box_cb,
                          &sc,
                          RMO_NONE,
                          GNUNET_NO);
      GNUNET_assert (NULL != sc.best->bpm);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "%lu %lu %lu %lu %u\n",
                  sizeof(struct GNUNET_PeerIdentity),
                  sizeof(struct TransportDVBoxMessage),
                  sizeof(struct TransportDVBoxPayloadP),
                  sizeof(struct TransportFragmentBoxMessage),
                  ((const struct GNUNET_MessageHeader *) &sc.best[1])->size);
      sc.best->bpm->used_dvh = sc.dvh;
    }
    pm = sc.best->bpm;
  }
  if (GNUNET_YES == sc.frag)
  {
    pm = fragment_message (queue, sc.dvh, pm);
    if (NULL == pm)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Fragmentation failed queue %s to %s for <%" PRIu64
                  ">, trying again\n",
                  queue->address,
                  GNUNET_i2s (&n->pid),
                  sc.best->logging_uuid);
      /* NOT with a zero delay: nothing about @a queue or about the message
         changed between here and the next pass, so "trying again" at once
         is a busy loop that reproduces the failure at scheduler speed. */
      schedule_transmit_on_queue (MIN_ACK_WAIT_DURATION,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
      return;
    }
  }
  else if (GNUNET_YES == sc.relb)
  {
    pm = reliability_box_message (queue, sc.dvh, pm);
    if (NULL == pm)
    {
      /* Reliability boxing failed, try next message... */
      GNUNET_log (
        GNUNET_ERROR_TYPE_DEBUG,
        "Reliability boxing failed queue %s to %s for <%" PRIu64
        ">, trying again\n",
        queue->address,
        GNUNET_i2s (&n->pid),
        sc.best->logging_uuid);
      /* Same reasoning as for the fragmentation failure above. */
      schedule_transmit_on_queue (MIN_ACK_WAIT_DURATION,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
      return;
    }
  }
 
  /* Pass 'pm' for transission to the communicator */
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Passing message <%" PRIu64
    "> to queue %s for peer %s (considered %u others)\n",
    pm->logging_uuid,
    queue->address,
    GNUNET_i2s (&n->pid),
    sc.consideration_counter);
 
  /* Flow control: increment amount of traffic sent; if we are routing
     via DV (and thus the ultimate target of the pending message is for
     a different virtual link than the one of the queue), then we need
     to use up not only the window of the direct link but also the
     flow control window for the DV link! */
  pm->vl->outbound_fc_window_size_used += pm->bytes_msg;
 
  if (pm->vl != queue->neighbour->vl)
  {
    /* If the virtual link of the queue differs, this better be distance
       vector routing! */
    GNUNET_assert (NULL != sc.dvh);
    /* If we do distance vector routing, we better not do this for a
       message that was itself DV-routed */
    GNUNET_assert (PMT_DV_BOX != sc.best->pmt);
    /* We use the size of the unboxed message here, to avoid counting
       the DV-Box header which is eaten up on the way by intermediaries.
       The next hop need not have a link of its own, in which case there is
       no window of it to charge. */
    if (NULL != queue->neighbour->vl)
      queue->neighbour->vl->outbound_fc_window_size_used += sc.best->bytes_msg;
  }
  else
  {
    GNUNET_assert (NULL == sc.dvh);
  }
 
  queue_send_msg (queue, pm, &pm[1], pm->bytes_msg);
 
  /* The message is with the communicator now, so return the CORE send
     window credit for it -- see #credit_client().
 
     It used to be returned here only for an unboxed message or a reliable
     communicator, and otherwise not until the *peer* acknowledged the
     message below.  That makes a window into a delivery confirmation: over
     an unreliable communicator every reliability-boxed or fragmented
     message holds one of the client's #SEND_WINDOW_SIZE slots for as long
     as its ACK takes, and a lost ACK holds it for the whole retransmission
     chain.  Four of those and CORE cannot send to that peer at all -- not
     payload, but also not its HEARTBEATs and not one message of its key
     exchange.  So the session times out for want of a heartbeat that is
     sitting in a queue, and the handshake that would rebuild it cannot go
     out either; CORE only recovers when a reconnect resets the window
     wholesale.  Acknowledgements still drive retransmission below, they
     just no longer gate the client. */
  credit_client (sc.best);
 
  /* Check if this transmission somehow conclusively finished handing 'pm'
     even without any explicit ACKs */
  if ((PMT_CORE == pm->pmt) ||
      (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc))
  {
    completed_pending_message (pm);
  }
  else
  {
    struct GNUNET_TIME_Relative wait_duration;
    unsigned int wait_multiplier;
 
    if (PMT_FRAGMENT_BOX == pm->pmt)
    {
      struct PendingMessage *root;
 
      root = pm->frag_parent;
      while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
        root = root->frag_parent;
 
      if ((0 == root->frag_off) || (0 == root->frag_count))
      {
        wait_multiplier = 4;
      }
      else
      {
        double wm = ceil ((double) root->bytes_msg
                          / ((double) root->frag_off
                             / (double) root->frag_count)) * 4.0;
 
        if ((! (wm >= 1.0)) || (wm > 1024.0))
          wm = 4.0;   /* NaN, infinity or absurd: fall back to the default */
        wait_multiplier = (unsigned int) wm;
      }
    }
    else
    {
      // No fragments, we use 4 RTT before retransmitting.
      wait_multiplier = 4;
    }
 
    // Depending on how much pending message the VirtualLink is queueing, we wait longer.
    // wait_multiplier = wait_multiplier * pm->vl->pending_msg_num;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Wait multiplier %u\n",
                wait_multiplier);
 
    /* Message not finished, waiting for acknowledgement.
       Update time by which we might retransmit 's' based on queue
       characteristics (i.e. RTT); it takes one RTT for the message to
       arrive and the ACK to come back in the best case; but the other
       side is allowed to delay ACKs by 2 RTTs, so we use 4 RTT before
       retransmitting.
 
       OPTIMIZE: Note that in the future this heuristic should likely
       be improved further (measure RTT stability, consider message
       urgency and size when delaying ACKs, etc.) */
 
    if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
        queue->pd.aged_rtt.rel_value_us)
      wait_duration = GNUNET_TIME_relative_max (queue->pd.aged_rtt,
                                                MIN_ACK_WAIT_DURATION);
    else
    {
      wait_duration = DEFAULT_ACK_WAIT_DURATION;
      wait_multiplier = 4;
    }
    {
      struct GNUNET_TIME_Absolute next = GNUNET_TIME_relative_to_absolute (
        GNUNET_TIME_relative_multiply (
          wait_duration, wait_multiplier));
      struct GNUNET_TIME_Relative plus = GNUNET_TIME_relative_multiply (
        wait_duration, wait_multiplier);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Waiting %s for ACK until %s\n",
                  GNUNET_STRINGS_relative_time_to_string (plus, GNUNET_NO),
                  GNUNET_STRINGS_absolute_time_to_string (next));
      update_pm_next_attempt (pm,
                              GNUNET_TIME_relative_to_absolute (
                                GNUNET_TIME_relative_multiply (wait_duration,
                                                               wait_multiplier))
                              );
    }
  }
  /* finally, re-schedule queue transmission task itself */
  schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                              queue,
                              GNUNET_SCHEDULER_PRIORITY_DEFAULT);
}
 
 
static void
handle_del_queue_message (void *cls,
                          const struct GNUNET_TRANSPORT_DelQueueMessage *dqm)
{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    struct Neighbour *neighbour = queue->neighbour;
 
    if ((ntohl (dqm->qid) != queue->qid) ||
        (0 != GNUNET_memcmp (&dqm->receiver, &neighbour->pid)))
      continue;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Dropped queue %s to peer %s\n",
                queue->address,
                GNUNET_i2s (&neighbour->pid));
    free_queue (queue);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  /* Not finding the queue is a race, not a protocol violation: we may have
     freed it ourselves already, or the communicator may be tearing down a
     queue we never fully learned about.  Do NOT drop the client over it --
     that runs #client_disconnect_cb(), which frees *every* queue this
     communicator owns, so one stale QUEUE_TEARDOWN would disconnect us from
     every peer it serves at once.  Compare #handle_send_message_ack(), which
     tolerates the same lookup miss. */
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "QUEUE_TEARDOWN for unknown queue QID %u to peer %s ignored\n",
              ntohl (dqm->qid),
              GNUNET_i2s (&dqm->receiver));
  GNUNET_STATISTICS_update (GST_stats,
                            "# QUEUE_TEARDOWN dropped: queue unknown",
                            1,
                            GNUNET_NO);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
free_queue_entry (struct QueueEntry *qe,
                  struct TransportClient *tc)
{
  struct PendingMessage *pm;
 
  GNUNET_CONTAINER_DLL_remove (qe->queue->queue_head,
                               qe->queue->queue_tail,
                               qe);
  qe->queue->queue_length--;
  tc->details.communicator.total_queue_length--;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ACK on queue %s (QID %u) to peer %s (new length: %u/%u)\n",
              qe->queue->address,
              qe->queue->qid,
              GNUNET_i2s (&qe->queue->neighbour->pid),
              qe->queue->queue_length,
              tc->details.communicator.total_queue_length);
 
  /* if applicable, resume transmissions that waited on ACK */
  if (COMMUNICATOR_TOTAL_QUEUE_LIMIT - 1 ==
      tc->details.communicator.total_queue_length)
  {
    /* Communicator dropped below threshold, resume all queues
       incident with this client! */
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Transmission throttled due to communicator queue limit",
      -1,
      GNUNET_NO);
    for (struct Queue *queue = tc->details.communicator.queue_head;
         NULL != queue;
         queue = queue->next_client)
    {
      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
    }
  }
  else if (QUEUE_LENGTH_LIMIT - 1 == qe->queue->queue_length)
  {
    /* queue dropped below threshold; only resume this one queue */
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to queue queue limit",
                              -1,
                              GNUNET_NO);
    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                qe->queue,
                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  }
  else if (1 == qe->queue->q_capacity)
  {
    // TODO I guess this will never happen, because the communicator triggers this by updating its queue length itself.
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission rescheduled due to communicator message queue with qid %u has capacity %"
                PRIu64 ".\n",
                qe->queue->qid,
                qe->queue->q_capacity);
    /* message queue has capacity; only resume this one queue */
    /* queue dropped below threshold; only resume this one queue */
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to message queue capacity",
                              -1,
                              GNUNET_NO);
    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                qe->queue,
                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  }
 
  if (NULL != (pm = qe->pm))
  {
    struct VirtualLink *vl;
 
    // GNUNET_assert (qe == pm->qe);
    pm->qe = NULL;
    /* If waiting for this communicator may have blocked transmission
       of pm on other queues for this neighbour, force schedule
       transmit on queue for queues of the neighbour */
    if (NULL == pm->frag_parent)
    {
      vl = pm->vl;
      if ((NULL != vl) &&
          (NULL != vl->pending_msg_head) &&
          (vl->pending_msg_head == pm))
        check_vl_transmission (vl);
    }
  }
  GNUNET_free (qe);
}
 
 
static void
handle_send_message_ack (void *cls,
                         const struct GNUNET_TRANSPORT_SendMessageToAck *sma)
{
  struct TransportClient *tc = cls;
  struct QueueEntry *qe;
  struct Queue *failed_queue = NULL;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
 
  /* find our queue entry matching the ACK */
  qe = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Looking for queue for PID %s\n",
              GNUNET_i2s (&sma->receiver));
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    if (0 != GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver))
      continue;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Found PID %s\n",
                GNUNET_i2s (&queue->neighbour->pid));
 
 
    for (struct QueueEntry *qep = queue->queue_head; NULL != qep;
         qep = qep->next)
    {
      if (qep->mid != GNUNET_ntohll (sma->mid) || queue->qid != ntohl (
            sma->qid))
        continue;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "QueueEntry MID: %" PRIu64 " on queue QID: %u, Ack MID: %"
                  PRIu64 " Ack QID %u\n",
                  qep->mid,
                  queue->qid,
                  GNUNET_ntohll (sma->mid),
                  ntohl (sma->qid));
      qe = qep;
      if ((NULL != qe->pm) && (qe->pm->qe != qe))
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "For pending message %" PRIu64 " we had retransmissions.\n",
                    qe->pm->logging_uuid);
      break;
    }
  }
  if (GNUNET_OK != (int) ntohl (sma->status))
  {
    /* The communicator could not hand the message to the peer.  The only
       thing that produces this today is #handle_send_msg()'s "queue no
       longer exists" branch in `transport_api_communication.c', i.e. the
       communicator has already torn the queue down on its side and the
       QUEUE_TEARDOWN is merely still in flight (or was lost).
 
       Ignoring the status, as we used to, makes this self-sustaining:
       #free_queue_entry() releases the pending message and immediately
       reschedules transmission, #transmit_on_queue() picks the very same
       queue again -- transport still has it -- and we get another failure.
       Every round adds an envelope to the client MQ that is already
       congested, which is what shows up at the other end as
 
         communicator INFO Transmission failed, queue no longer exists.
 
       repeating at scheduler speed, and (because the service is busy
       servicing that loop) as
 
         communicator WARNING Dropping message: transport is too slow,
                              queue length N exceeded
 
       on every *other* communicator.  Treat the failure as the queue
       teardown it is and stop selecting this queue. */
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Communicator could not send MID %" PRIu64
                " on QID %u to %s; dropping that queue\n",
                GNUNET_ntohll (sma->mid),
                ntohl (sma->qid),
                GNUNET_i2s (&sma->receiver));
    GNUNET_STATISTICS_update (GST_stats,
                              "# queues dropped (communicator send failed)",
                              1,
                              GNUNET_NO);
    if (NULL != qe)
      failed_queue = qe->queue;
    else
      for (struct Queue *queue = tc->details.communicator.queue_head;
           NULL != queue;
           queue = queue->next_client)
        if ((ntohl (sma->qid) == queue->qid) &&
            (0 == GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver)))
        {
          failed_queue = queue;
          break;
        }
    if (NULL != failed_queue)
    {
      /* #free_queue() releases every `struct QueueEntry' still on it --
         including @a qe -- and detaches their pending messages, so they are
         retried on whatever other queue this neighbour has. */
      free_queue (failed_queue);
      GNUNET_SERVICE_client_continue (tc->client);
      return;
    }
  }
  if (NULL == qe)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No QueueEntry found for Ack MID %" PRIu64 " QID: %u\n",
                GNUNET_ntohll (sma->mid),
                ntohl (sma->qid));
    // TODO I guess this can happen, if the Ack from the peer comes before the Ack from the queue.
    // Update: Maybe QueueEntry was accidentally freed during freeing PendingMessage.
    /* this should never happen */
    // GNUNET_break (0);
    // GNUNET_SERVICE_client_drop (tc->client);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  free_queue_entry (qe, tc);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
handle_burst_finished (void *cls,
                       const struct GNUNET_TRANSPORT_BurstFinished *bf)
{
  struct TransportClient *tc = cls;
 
  (void) bf;
  burst_running = GNUNET_NO;
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static int
notify_client_queues (void *cls,
                      const struct GNUNET_PeerIdentity *pid,
                      void *value)
{
  struct TransportClient *tc = cls;
  struct Neighbour *neighbour = value;
 
  GNUNET_assert (CT_MONITOR == tc->type);
  for (struct Queue *q = neighbour->queue_head; NULL != q;
       q = q->next_neighbour)
  {
    struct MonitorEvent me = { .rtt = q->pd.aged_rtt,
                               .cs = q->cs,
                               .num_msg_pending = q->num_msg_pending,
                               .num_bytes_pending = q->num_bytes_pending };
 
    notify_monitor (tc, pid, q->address, q->nt, &me);
  }
  return GNUNET_OK;
}
 
 
static void
handle_monitor_start (void *cls,
                      const struct GNUNET_TRANSPORT_MonitorStart *start)
{
  struct TransportClient *tc = cls;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  tc->type = CT_MONITOR;
  tc->details.monitor.peer = start->peer;
  tc->details.monitor.one_shot = ntohl (start->one_shot);
  GNUNET_CONTAINER_multipeermap_iterate (neighbours, &notify_client_queues, tc);
  GNUNET_SERVICE_client_mark_monitor (tc->client);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
struct LinkListContext
{
  struct TransportClient *tc;
 
  int include_unconfirmed;
};
 
 
static char *
communicator_list (struct Neighbour *n,
                   unsigned int *num_queues)
{
  char *ret = GNUNET_strdup ("");
 
  *num_queues = 0;
  if (NULL == n)
    return ret;
  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
  {
    const char *prefix = q->tc->details.communicator.address_prefix;
    size_t plen = strlen (prefix);
    const char *pos;
    char *tmp;
 
    (*num_queues)++;
    if (0 == plen)
      continue;
    /* Several queues to one neighbour routinely share a communicator;
       name each one once. */
    for (pos = strstr (ret, prefix);
         NULL != pos;
         pos = strstr (pos + 1, prefix))
      if (((pos == ret) || (',' == pos[-1])) &&
          (('\0' == pos[plen]) || (',' == pos[plen])))
        break;
    if (NULL != pos)
      continue;
    GNUNET_asprintf (&tmp, "%s%s%s", ret, ('\0' == ret[0]) ? "" : ",", prefix);
    GNUNET_free (ret);
    ret = tmp;
  }
  return ret;
}
 
 
static enum GNUNET_GenericReturnValue
report_link (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
{
  struct LinkListContext *llc = cls;
  struct VirtualLink *vl = value;
  struct GNUNET_TRANSPORT_LinkListResponse *resp;
  struct GNUNET_MQ_Envelope *env;
  unsigned int pending = 0;
  unsigned int num_queues = 0;
  unsigned int distance = 0;
  struct Neighbour *hop;
  char *ccs;
  size_t clen;
 
  if ((GNUNET_YES != llc->include_unconfirmed) &&
      (GNUNET_YES != vl->confirmed))
    return GNUNET_OK;
  for (struct PendingMessage *pm = vl->pending_msg_head;
       NULL != pm;
       pm = pm->next_vl)
    pending++;
  if (NULL != vl->n)
  {
    hop = vl->n;
  }
  else
  {
    /* Report the best (shortest) of the paths we currently know, and the
       communicators that carry its first hop. */
    struct DistanceVectorHop *best = NULL;
 
    distance = UINT_MAX;
    if (NULL != vl->dv)
      for (struct DistanceVectorHop *pos = vl->dv->dv_head;
           NULL != pos;
           pos = pos->next_dv)
        if (pos->distance < distance)
        {
          distance = pos->distance;
          best = pos;
        }
    if (NULL == best)
      distance = 0;   /* no paths left; report the link as adjacent */
    hop = (NULL != best) ? best->next_hop : NULL;
  }
  ccs = communicator_list (hop, &num_queues);
  clen = strlen (ccs) + 1;
  env = GNUNET_MQ_msg_extra (resp,
                             clen,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE);
  memcpy (&resp[1], ccs, clen);
  GNUNET_free (ccs);
  resp->target = *pid;
  resp->confirmed = htonl ((uint32_t) vl->confirmed);
  resp->route = htonl ((uint32_t) ((NULL != vl->n)
                                   ? GNUNET_TRANSPORT_LINK_ROUTE_DIRECT
                                   : GNUNET_TRANSPORT_LINK_ROUTE_DV));
  resp->distance = htonl ((uint32_t) distance);
  resp->num_queues = htonl ((uint32_t) num_queues);
  resp->core_recv_window = htonl ((int32_t) vl->core_recv_window);
  resp->stalled = htonl ((uint32_t) vl->cmc_count);
  resp->pending = htonl (pending);
  resp->fc_retransmit_count = htonl ((uint32_t) vl->fc_retransmit_count);
  resp->available_fc_window_size
    = GNUNET_htonll (vl->available_fc_window_size);
  resp->incoming_fc_window_size_ram
    = GNUNET_htonll (vl->incoming_fc_window_size_ram);
  resp->incoming_fc_window_size
    = GNUNET_htonll (vl->incoming_fc_window_size);
  resp->incoming_fc_window_size_used
    = GNUNET_htonll (vl->incoming_fc_window_size_used);
  resp->incoming_fc_window_size_loss
    = GNUNET_htonll ((uint64_t) vl->incoming_fc_window_size_loss);
  resp->outbound_fc_window_size
    = GNUNET_htonll (vl->outbound_fc_window_size);
  resp->outbound_fc_window_size_used
    = GNUNET_htonll (vl->outbound_fc_window_size_used);
  resp->last_fc_rtt = GNUNET_TIME_relative_hton (vl->last_fc_rtt);
  resp->other_rtt = GNUNET_TIME_relative_hton (vl->other_rtt);
  resp->last_fc_transmission
    = GNUNET_TIME_absolute_hton (vl->last_fc_transmission);
  GNUNET_MQ_send (llc->tc->mq, env);
  return GNUNET_OK;
}
 
 
static void
handle_link_list_request (
  void *cls,
  const struct GNUNET_TRANSPORT_LinkListRequest *lr)
{
  struct TransportClient *tc = cls;
  struct LinkListContext llc = {
    .tc = tc,
    .include_unconfirmed = (int) ntohl (lr->include_unconfirmed)
  };
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *end;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  if (GNUNET_YES == GNUNET_is_zero (&lr->peer))
  {
    GNUNET_CONTAINER_multipeermap_iterate (links, &report_link, &llc);
  }
  else
  {
    struct VirtualLink *vl = lookup_virtual_link (&lr->peer);
 
    if (NULL != vl)
      report_link (&llc, &lr->peer, vl);
  }
  env = GNUNET_MQ_msg (end,
                       GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE_END);
  GNUNET_MQ_send (tc->mq, env);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static struct TransportClient *
lookup_communicator (const char *prefix)
{
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_COMMUNICATOR != tc->type)
      continue;
    if (NULL == tc->details.communicator.address_prefix)
      continue;   /* receive-only communicator */
    if (0 == strcmp (prefix, tc->details.communicator.address_prefix))
      return tc;
  }
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Someone suggested use of communicator for `%s', but we do not have such a communicator!\n",
    prefix);
  return NULL;
}
 
 
static void
suggest_to_connect (const struct GNUNET_PeerIdentity *pid, const char *address)
{
  static uint32_t idgen = 0;
  struct TransportClient *tc;
  char *prefix;
  struct GNUNET_TRANSPORT_CreateQueue *cqm;
  struct GNUNET_MQ_Envelope *env;
  size_t alen;
 
  prefix = GNUNET_HELLO_address_to_prefix (address);
  if (NULL == prefix)
  {
    GNUNET_break (0);  /* We got an invalid address!? */
    return;
  }
  tc = lookup_communicator (prefix);
  if (NULL == tc)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# Suggestions ignored due to missing communicator",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Cannot connect to %s at `%s', no matching communicator present\n",
                GNUNET_i2s (pid),
                address);
    GNUNET_free (prefix);
    return;
  }
  /* forward suggestion for queue creation to communicator */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Request #%u for `%s' communicator to create queue to `%s' at `%s'\n",
              (unsigned int) idgen,
              prefix,
              GNUNET_i2s (pid),
              address);
  GNUNET_free (prefix);
  alen = strlen (address) + 1;
  env =
    GNUNET_MQ_msg_extra (cqm, alen, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE);
  cqm->request_id = htonl (idgen++);
  cqm->receiver = *pid;
  memcpy (&cqm[1], address, alen);
  GNUNET_MQ_send (tc->mq, env);
}
 
 
static void
validation_transmit_on_queue (struct Queue *q, struct ValidationState *vs)
{
  struct TransportValidationChallengeMessage tvc;
  struct GNUNET_TIME_Absolute monotonic_time;
 
  if (NULL != vs->revalidation_task)
  {
    GNUNET_SCHEDULER_cancel (vs->revalidation_task);
    vs->revalidation_task = NULL;
  }
  /*memcpy (&hkey,
          &hc,
          sizeof (hkey));*/
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Remove key %s for address %s map size %u contains %u\n",
              GNUNET_h2s (&vs->hc),
              vs->address,
              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
                                                      &vs->hc));
  GNUNET_CONTAINER_multihashmap_remove (revalidation_map, &vs->hc, vs);
 
  monotonic_time  = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
      vs->last_challenge_use.abs_value_us)
  {
    vs->first_challenge_use = monotonic_time;
  }
  vs->last_challenge_use = monotonic_time;
  tvc.header.type =
    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE);
  tvc.header.size = htons (sizeof(tvc));
  tvc.reserved = htonl (0);
  tvc.challenge = vs->challenge;
  tvc.sender_time = GNUNET_TIME_absolute_hton (vs->last_challenge_use);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Sending address validation challenge %s to %s\n",
              GNUNET_sh2s (&tvc.challenge.value),
              GNUNET_i2s (&q->neighbour->pid));
  queue_send_msg (q, NULL, &tvc, sizeof(tvc));
}
 
 
static struct GNUNET_TIME_Relative
validation_challenge_freq (const struct GNUNET_PeerIdentity *pid)
{
  const struct VirtualLink *vl = lookup_virtual_link (pid);
 
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
    return MAX_VALIDATION_CHALLENGE_FREQ;   /* we have what we want */
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_APPLICATION != tc->type)
      continue;
    if (NULL != GNUNET_CONTAINER_multipeermap_get (
          tc->details.application.requests,
          pid))
      return WANTED_VALIDATION_CHALLENGE_FREQ;
  }
  return MAX_VALIDATION_CHALLENGE_FREQ;
}
 
 
static void
validation_start_cb (void *cls)
{
  struct ValidationState *vs;
  struct Queue *q;
  const struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get_monotonic (
    GST_cfg);
 
  (void) cls;
  validation_task = NULL;
  vs = GNUNET_CONTAINER_heap_peek (validation_heap);
  /* drop validations past their expiration */
  while (
    (NULL != vs) &&
    (0 == GNUNET_TIME_absolute_get_remaining (vs->valid_until).rel_value_us))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Validation response %s cleaned up\n",
                GNUNET_sh2s (&vs->challenge.value));
    free_validation_state (vs);
    vs = GNUNET_CONTAINER_heap_peek (validation_heap);
  }
  if (NULL == vs)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Address validation task not scheduled anymore, nothing to do\n");
    return;   /* woopsie, no more addresses known, should only
                 happen if we're really a lonely peer */
  }
  q = find_queue (&vs->pid, vs->address);
  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "To early to start next address validation for challenge %s\n",
                GNUNET_sh2s (&vs->challenge.value));
    /* Do NOT just return: @e validation_task was set to NULL above and
       nothing re-arms it by itself.  #update_next_challenge_time() only
       schedules us again when it is called with a *changed* time for some
       validation state, so bailing out here leaves a non-empty
       #validation_heap with no task attached: address (re)validation and
       the #suggest_to_connect() retries that go with it stop for *every*
       peer until some unrelated event happens to come along.  A peer that
       just lost its only connection has no such events left. */
    validation_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_difference (
                                      now,
                                      vs->first_challenge_use),
                                    &validation_start_cb,
                                    NULL);
    return;
  }
  if (NULL == q)
  {
    vs->awaiting_queue = GNUNET_YES;
    suggest_to_connect (&vs->pid, vs->address);
  }
  else
    validation_transmit_on_queue (q, vs);
  /* Finally, reschedule next attempt */
  vs->challenge_backoff =
    GNUNET_TIME_randomized_backoff (vs->challenge_backoff,
                                    validation_challenge_freq (&vs->pid));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Address validation task will run again in %s\n",
              GNUNET_STRINGS_relative_time_to_string (vs->challenge_backoff,
                                                      GNUNET_YES));
  update_next_challenge_time (vs,
                              GNUNET_TIME_relative_to_absolute (
                                vs->challenge_backoff));
}
 
 
struct QueueQualityContext
{
  struct Queue *q;
 
  unsigned int quality_count;
 
  unsigned int num_queues;
 
  unsigned int k;
};
 
 
static int
check_connection_quality (void *cls,
                          const struct GNUNET_PeerIdentity *pid,
                          void *value)
{
  struct QueueQualityContext *ctx = cls;
  struct Neighbour *n = value;
  int do_inc;
 
  (void) pid;
  do_inc = GNUNET_NO;
  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
  {
    ctx->num_queues++;
    if (0 == ctx->k--)
      ctx->q = q;
    /* FIXME-CONQ-STATISTICS: in the future, add reliability / goodput
       statistics and consider those as well here? */
    if (q->pd.aged_rtt.rel_value_us < DV_QUALITY_RTT_THRESHOLD.rel_value_us)
      do_inc = GNUNET_YES;
  }
  if (GNUNET_YES == do_inc)
    ctx->quality_count++;
  return GNUNET_OK;
}
 
 
static void
start_dv_learn (void *cls);
 
 
static void
transmit_dv_init (struct TransportDVLearnMessage dvl,
                  struct LearnLaunchEntry *lle,
                  struct QueueQualityContext qqc)
{
  if (0 == qqc.num_queues)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV learn aborted: no queue left",
                              1,
                              GNUNET_NO);
    return;
  }
  qqc.quality_count = 0;
  qqc.k = GNUNET_CRYPTO_random_u32 (qqc.num_queues);
  qqc.num_queues = 0;
  qqc.q = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &check_connection_quality,
                                         &qqc);
  if (NULL == qqc.q)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV learn aborted: no queue left",
                              1,
                              GNUNET_NO);
    return;
  }
 
  /* Do this as close to transmission time as possible! */
  lle->launch_time = GNUNET_TIME_absolute_get ();
 
  queue_send_msg (qqc.q, NULL, &dvl, sizeof(dvl));
  /* reschedule this job, randomizing the time it runs (but no
     actual backoff!) */
  if (NULL != dvlearn_task)
    GNUNET_SCHEDULER_cancel (dvlearn_task);
  dvlearn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_randomize (
                                                 DV_LEARN_BASE_FREQUENCY),
                                               &start_dv_learn,
                                               NULL);
}
 
 
static void
start_dv_learn (void *cls)
{
  struct LearnLaunchEntry *lle;
  struct QueueQualityContext qqc;
  struct TransportDVLearnMessage dvl;
  const struct GNUNET_PeerIdentity *my_identity;
 
  (void) cls;
  dvlearn_task = NULL;
  if ((GNUNET_YES == in_shutdown) || (NULL == pils))
    return;
  if (0 == GNUNET_CONTAINER_multipeermap_size (neighbours))
    return; /* lost all connectivity, cannot do learning */
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    /* PILS has not handed us an identity yet.  The first queue arriving
       schedules us with add_now(), which routinely wins that race; retry
       instead of taking the service down. */
    dvlearn_pils_backoff = GNUNET_TIME_STD_BACKOFF (dvlearn_pils_backoff);
    dvlearn_task = GNUNET_SCHEDULER_add_delayed (dvlearn_pils_backoff,
                                                 &start_dv_learn,
                                                 NULL);
    return;
  }
  dvlearn_pils_backoff = GNUNET_TIME_UNIT_ZERO;
  qqc.quality_count = 0;
  qqc.num_queues = 0;
  qqc.k = GNUNET_CONTAINER_multipeermap_size (neighbours);
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &check_connection_quality,
                                         &qqc);
  if (qqc.quality_count > DV_LEARN_QUALITY_THRESHOLD)
  {
    struct GNUNET_TIME_Relative delay;
    unsigned int factor;
 
    /* scale our retries by how far we are above the threshold */
    factor = qqc.quality_count / DV_LEARN_QUALITY_THRESHOLD;
    delay = GNUNET_TIME_relative_multiply (DV_LEARN_BASE_FREQUENCY, factor);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "At connection quality %u, will launch DV learn in %s\n",
                qqc.quality_count,
                GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
    dvlearn_task = GNUNET_SCHEDULER_add_delayed (delay, &start_dv_learn, NULL);
    return;
  }
  /* remove old entries in #dvlearn_map if it has grown too big */
  while (MAX_DV_LEARN_PENDING <=
         GNUNET_CONTAINER_multishortmap_size (dvlearn_map))
  {
    lle = lle_tail;
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multishortmap_remove (dvlearn_map,
                                                          &lle->challenge.value,
                                                          lle));
    GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
    GNUNET_free (lle);
  }
  /* setup data structure for learning */
  lle = GNUNET_new (struct LearnLaunchEntry);
  GNUNET_CRYPTO_random_block (&lle->challenge,
                              sizeof(lle->challenge));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting launch DV learn with challenge %s\n",
              GNUNET_sh2s (&lle->challenge.value));
  GNUNET_CONTAINER_DLL_insert (lle_head, lle_tail, lle);
  GNUNET_break (GNUNET_YES ==
                GNUNET_CONTAINER_multishortmap_put (
                  dvlearn_map,
                  &lle->challenge.value,
                  lle,
                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  dvl.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
  dvl.header.size = htons (sizeof(dvl));
  dvl.num_hops = htons (0);
  dvl.bidirectional = htons (0);
  dvl.non_network_delay = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO);
  dvl.monotonic_time =
    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (GST_cfg));
  // We will set the below again later
  memset (&dvl.init_sig, 0, sizeof dvl.init_sig);
  dvl.challenge = lle->challenge;
  dvl.initiator = *my_identity;
  {
    struct DvInitPS dvip = {
      .purpose.purpose = htonl (
        GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
      .purpose.size = htonl (sizeof(dvip)),
      .monotonic_time = dvl.monotonic_time,
      .challenge = lle->challenge
    };
 
    if (GNUNET_OK != sign_by_my_identity (&dvip.purpose, &dvl.init_sig))
      return;
  }
  transmit_dv_init (dvl, lle, qqc);
}
 
 
static char *
get_address_without_port (const char *address)
{
  const char *dash;
  const char *colon;
 
  if (NULL == address)
    return NULL;
  dash = strchr (address, '-');
  if (NULL == dash)
    return NULL;
  colon = strchr (dash, ':');
  if (NULL == colon)
    return NULL;
  return GNUNET_strndup (dash + 1,
                         colon - (dash + 1));
}
 
 
static int
check_validation_request_pending (void *cls,
                                  const struct GNUNET_PeerIdentity *pid,
                                  void *value)
{
  struct Queue *q = cls;
  struct ValidationState *vs = value;
  char *address_without_port_vs;
  char *address_without_port_q;
  char *prefix_vs;
  char *prefix_q;
  int success = GNUNET_YES;
 
  // TODO Check if this is really necessary.
  address_without_port_vs = get_address_without_port (vs->address);
  address_without_port_q = get_address_without_port (q->address);
  prefix_vs = GNUNET_HELLO_address_to_prefix (vs->address);
  prefix_q = GNUNET_HELLO_address_to_prefix (q->address);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Check validation request pending for `%s' at `%s'/`%s' (vs)/(q)\n",
              GNUNET_i2s (pid),
              (NULL == address_without_port_vs) ? "<unparsable>"
              : address_without_port_vs,
              (NULL == address_without_port_q) ? "<unparsable>"
              : address_without_port_q);
  (void) pid;
  /* Only the port may differ: the address we asked to connect to is
     `PROTO-IP:0' for a NATed peer, while the queue that then materializes
     sits at `PROTO-IP:port'.  The communicator must match all the same --
     a challenge for a `tcp-' address is not answered by a `udp-' queue. */
  if ((GNUNET_YES == vs->awaiting_queue) &&
      (NULL != address_without_port_vs) &&
      (NULL != address_without_port_q) &&
      (NULL != prefix_vs) &&
      (NULL != prefix_q) &&
      (0 == strcmp (prefix_vs, prefix_q)) &&
      (0 == strcmp (address_without_port_vs, address_without_port_q)))
  {
 
    vs->awaiting_queue = GNUNET_NO;
    validation_transmit_on_queue (q, vs);
    success = GNUNET_NO;
  }
 
  GNUNET_free (address_without_port_vs);
  GNUNET_free (address_without_port_q);
  GNUNET_free (prefix_vs);
  GNUNET_free (prefix_q);
  return success;
}
 
 
static void
neighbour_dv_monotime_cb (void *cls,
                          const struct GNUNET_PEERSTORE_Record *record,
                          const char *emsg)
{
  struct Neighbour *n = cls;
  struct GNUNET_TIME_AbsoluteNBO *mtbe;
 
  (void) emsg;
  if (NULL == record)
  {
    /* we're done with #neighbour_dv_monotime_cb() invocations,
       continue normal processing */
    n->get = NULL;
    n->dv_monotime_available = GNUNET_YES;
    return;
  }
  if (0 == record->value_size)
  {
    GNUNET_PEERSTORE_iteration_next (n->get, 1);
    GNUNET_break (0);
    return;
  }
  mtbe = record->value;
  n->last_dv_learn_monotime =
    GNUNET_TIME_absolute_max (n->last_dv_learn_monotime,
                              GNUNET_TIME_absolute_ntoh (*mtbe));
  GNUNET_PEERSTORE_iteration_next (n->get, 1);
}
 
 
static void
iterate_address_and_compare_cb (void *cls,
                                const struct GNUNET_PeerIdentity *pid,
                                const char *uri)
{
  struct Queue *queue = cls;
  struct sockaddr_in v4;
  const char *slash;
  char *address_uri;
  char *prefix;
  char *uri_without_port;
  char *address_uri_without_port;
 
  slash = strrchr (uri, '/');
  if ((NULL == slash) || (slash - uri < 2))
  {
    GNUNET_break_op (0);   /* @a uri comes from a remote HELLO */
    return;
  }
  prefix = GNUNET_strndup (uri, (slash - uri) - 2);
  slash++;
  GNUNET_asprintf (&address_uri,
                   "%s-%s",
                   prefix,
                   slash);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "1 not global natted_address %u %s %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address,
              slash);
 
  uri_without_port = get_address_without_port (address_uri);
  if ((NULL == uri_without_port) ||
      (1 != inet_pton (AF_INET, uri_without_port, &v4.sin_addr)))
  {
    GNUNET_free (prefix);
    GNUNET_free (address_uri);
    GNUNET_free (uri_without_port);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "2 not global natted_address %u %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address);
 
  if (GNUNET_NO == queue->is_global_natted)
  {
    GNUNET_free (prefix);
    GNUNET_free (address_uri);
    GNUNET_free (uri_without_port);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "3 not global natted_address %u %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address);
 
  if (0 == strcmp (uri_without_port, address_uri))
  {
    GNUNET_free (prefix);
    GNUNET_free (address_uri);
    GNUNET_free (uri_without_port);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "4 not global natted_address %u %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address);
 
  address_uri_without_port = get_address_without_port (queue->address);
  if ((NULL != address_uri_without_port) &&
      (0 == strcmp (uri_without_port, address_uri_without_port)))
  {
    queue->is_global_natted = GNUNET_NO;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "not global natted_address %u %s %s %s %s %s %u\n",
              queue->is_global_natted,
              uri,
              queue->address,
              uri_without_port,
              address_uri_without_port,
              prefix,
              GNUNET_NO);
  GNUNET_free (prefix);
  GNUNET_free (address_uri);
  GNUNET_free (address_uri_without_port);
  GNUNET_free (uri_without_port);
}
 
 
struct TransportGlobalNattedAddressClosure
{
  char *addr;
 
  struct TransportGlobalNattedAddress *tgna;
};
 
 
static enum GNUNET_GenericReturnValue
contains_address (void *cls,
                  const struct GNUNET_PeerIdentity *pid,
                  void *value)
{
  struct TransportGlobalNattedAddressClosure *tgna_cls = cls;
  struct TransportGlobalNattedAddress *tgna = value;
  char *addr = (char *) &tgna[1];
 
  /* NOTE: @a addr is NOT 0-terminated. */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Checking tgna %p with addr %.*s and length %u compare length %lu\n",
              tgna,
              (int) ntohl (tgna->address_length),
              addr,
              ntohl (tgna->address_length),
              strlen (tgna_cls->addr));
  if (strlen (tgna_cls->addr) == ntohl (tgna->address_length)
      && 0 == strncmp (addr, tgna_cls->addr, ntohl (tgna->address_length)))
  {
    tgna_cls->tgna = tgna;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}
 
 
static void
check_for_global_natted_error_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring for checking global natted\n");
}
 
 
static void
check_for_global_natted_sync_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Done with initial PEERSTORE iteration during monitoring  for checking global natted\n");
}
 
 
static void
check_for_global_natted (void *cls,
                         const struct GNUNET_PEERSTORE_Record *record,
                         const char *emsg)
{
  struct Queue *queue = cls;
  struct Neighbour *neighbour = queue->neighbour;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_MessageHeader *hello;
  struct TransportGlobalNattedAddressClosure tgna_cls;
  size_t address_len_without_port;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  /* @a hello was published by a remote peer and may be malformed. */
  hello = hello_from_record (record);
  if (NULL == hello)
  {
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  queue->is_global_natted = GNUNET_YES;
  parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
  if (NULL == parser)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "HELLO cannot be parsed!\n");
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "before not global natted %u\n",
              queue->is_global_natted);
  GNUNET_HELLO_parser_iterate (parser,
                               &iterate_address_and_compare_cb,
                               queue);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "after not global natted %u\n",
              queue->is_global_natted);
  GNUNET_HELLO_parser_free (parser);
 
  tgna_cls.addr = get_address_without_port (queue->address);
  if (NULL == tgna_cls.addr)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  address_len_without_port = strlen (tgna_cls.addr);
  /*{
    char buf[address_len_without_port + 1];
 
      GNUNET_memcpy (&buf, addr, address_len_without_port);
      buf[address_len_without_port] = '\0';
      GNUNET_free (addr);
      GNUNET_memcpy (tgna_cls.addr, buf, address_len_without_port + 1);
      }*/
  tgna_cls.tgna = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (neighbour->natted_addresses,
                                              &neighbour->pid,
                                              &contains_address,
                                              &tgna_cls);
  if (NULL != tgna_cls.tgna)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                " tgna_cls.tgna tgna %p %lu %u %u\n",
                tgna_cls.tgna,
                neighbour->size_of_global_addresses,
                ntohl (tgna_cls.tgna->address_length),
                neighbour->number_of_addresses);
  if (NULL == tgna_cls.tgna && GNUNET_YES == queue->is_global_natted)
  {
    struct TransportGlobalNattedAddress *tgna;
 
    tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress)
                          + address_len_without_port);
    tgna->address_length = htonl (address_len_without_port);
    GNUNET_memcpy (&tgna[1], tgna_cls.addr, address_len_without_port);
    GNUNET_CONTAINER_multipeermap_put (neighbour->natted_addresses,
                                       &neighbour->pid,
                                       tgna,
                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
    neighbour->number_of_addresses++;
    /* MUST match what is subtracted on removal (and what
       #add_global_addresses() actually copies), or the accounting drifts. */
    neighbour->size_of_global_addresses += address_len_without_port;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Created tgna %p with address %s and length %lu\n",
                tgna,
                tgna_cls.addr,
                address_len_without_port + 1);
  }
  else if (NULL != tgna_cls.tgna && GNUNET_NO == queue->is_global_natted)
  {
    GNUNET_CONTAINER_multipeermap_remove (neighbour->natted_addresses,
                                          &neighbour->pid,
                                          tgna_cls.tgna);
    GNUNET_assert (neighbour->size_of_global_addresses >= ntohl (tgna_cls.tgna->
                                                                 address_length)
                   );
    neighbour->size_of_global_addresses -= ntohl (tgna_cls.tgna->address_length)
    ;
    GNUNET_assert (0 < neighbour->number_of_addresses);
    neighbour->number_of_addresses--;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "removed tgna %p\n",
                tgna_cls.tgna);
    GNUNET_free (tgna_cls.tgna);
  }
  GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
  GNUNET_free (tgna_cls.addr);
}
 
 
static void
handle_add_queue_message (void *cls,
                          const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
{
  struct TransportClient *tc = cls;
  struct Queue *queue;
  struct Neighbour *neighbour;
  const char *addr;
  uint16_t addr_len;
 
  if (ntohl (aqm->mtu) <= sizeof(struct TransportFragmentBoxMessage))
  {
    /* MTU so small as to be useless for transmissions,
       required for #fragment_message()! */
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  /* This may simply be a queue update.  Match on the peer as well as the
     QID: the communicator's key for a queue is the pair, and
     #handle_send_msg() on its side looks both of them up.  Matching on the
     QID alone let an ADD_QUEUE for a *different* peer be folded into an
     existing queue, leaving @e neighbour pointing at the old peer -- after
     which every SEND_MSG we put on it carries a receiver the communicator
     cannot match, and comes straight back as "queue no longer exists". */
  for (queue = tc->details.communicator.queue_head;
       NULL != queue;
       queue = queue->next_client)
  {
    if (queue->qid != ntohl (aqm->qid))
      continue;
    if (0 != GNUNET_memcmp (&queue->neighbour->pid, &aqm->receiver))
      continue;
    break;
  }
 
  if (NULL != queue)
  {
    neighbour = queue->neighbour;
  }
  else
  {
    struct GNUNET_TIME_Absolute validated_until = GNUNET_TIME_UNIT_ZERO_ABS;
 
    neighbour = lookup_neighbour (&aqm->receiver);
    if (NULL == neighbour)
    {
      neighbour = GNUNET_new (struct Neighbour);
      neighbour->natted_addresses = GNUNET_CONTAINER_multipeermap_create (16,
                                                                          GNUNET_YES);
      neighbour->pid = aqm->receiver;
      /* Give a fresh neighbour a full window to say something. */
      neighbour->last_inbound = GNUNET_TIME_absolute_get ();
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CONTAINER_multipeermap_put (
                       neighbours,
                       &neighbour->pid,
                       neighbour,
                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
      neighbour->get =
        GNUNET_PEERSTORE_iteration_start (peerstore,
                                          "transport",
                                          &neighbour->pid,
                                          GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
                                          &neighbour_dv_monotime_cb,
                                          neighbour);
    }
    addr_len = ntohs (aqm->header.size) - sizeof(*aqm);
    addr = (const char *) &aqm[1];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "New queue %s to %s available with QID %u and q_len %" PRIu64
                " and mtu %u\n",
                addr,
                GNUNET_i2s (&aqm->receiver),
                ntohl (aqm->qid),
                GNUNET_ntohll (aqm->q_len),
                ntohl (aqm->mtu));
    queue = GNUNET_malloc (sizeof(struct Queue) + addr_len);
    queue->tc = tc;
    for (struct Queue *q = neighbour->queue_head; NULL != q; q = q->
                                                                 next_neighbour)
      validated_until = GNUNET_TIME_absolute_max (validated_until, q->
                                                  validated_until);
    /* Inherit the validity of the sibling queues, but only while it is
       still in the future -- copying an already expired timestamp is
       pointless (and the condition used to be inverted). */
    if (0 != GNUNET_TIME_absolute_get_remaining (validated_until).rel_value_us)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "New queue with QID %u inherit validated until\n",
                  ntohl (aqm->qid));
      queue->validated_until = validated_until;
    }
    queue->address = (const char *) &queue[1];
    queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
    queue->qid = ntohl (aqm->qid);
    queue->neighbour = neighbour;
    if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (aqm->q_len))
      queue->unlimited_length = GNUNET_YES;
    queue->q_capacity = GNUNET_ntohll (aqm->q_len);
    memcpy (&queue[1], addr, addr_len);
    /* notify monitors about new queue */
    {
      struct MonitorEvent me = { .rtt = queue->pd.aged_rtt, .cs = queue->cs };
 
      notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
    }
    GNUNET_CONTAINER_MDLL_insert (neighbour,
                                  neighbour->queue_head,
                                  neighbour->queue_tail,
                                  queue);
    GNUNET_CONTAINER_MDLL_insert (client,
                                  tc->details.communicator.queue_head,
                                  tc->details.communicator.queue_tail,
                                  queue);
 
  }
  queue->mtu = ntohl (aqm->mtu);
  queue->nt = ntohl (aqm->nt);
  queue->cs = ntohl (aqm->cs);
  queue->idle = GNUNET_YES;
 
  if (NULL == queue->mo)
  {
    /* Only for a NEW queue: on a queue update this used to start a second
       monitor and leak the first one. */
    struct sockaddr_in v4;
    char *addr_without = get_address_without_port (queue->address);
    if ((NULL != addr_without) &&
        (1 == inet_pton (AF_INET, addr_without, &v4.sin_addr)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "start not global natted\n");
      queue->mo = GNUNET_PEERSTORE_monitor_start (GST_cfg,
                                                  GNUNET_YES,
                                                  "peerstore",
                                                  &neighbour->pid,
                                                  GNUNET_PEERSTORE_HELLO_KEY,
                                                  &
                                                  check_for_global_natted_error_cb,
                                                  NULL,
                                                  &
                                                  check_for_global_natted_sync_cb,
                                                  NULL,
                                                  &check_for_global_natted,
                                                  queue);
    }
    GNUNET_free (addr_without);
  }
  /* check if valdiations are waiting for the queue */
  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (validation_map,
                                                            &aqm->receiver))
    (void) GNUNET_CONTAINER_multipeermap_get_multiple (
      validation_map,
      &aqm->receiver,
      &check_validation_request_pending,
      queue);
  /* Always (also) validate the address of the queue itself.  A pending
     validation served above may well be for a *different* address string:
     #check_validation_request_pending() matches on the IP only, so a
     validation state waiting for the NAT address `PROTO-IP:0' is happily
     satisfied by a queue at `PROTO-IP:12345'.  If we stopped here,
     #handle_validation_response() would later look for a queue at
     `PROTO-IP:0' -- which never exists -- and drop the successful
     validation on the floor without ever creating the virtual link.  That
     is exactly what happens to the second of two peers behind the same
     NAT, as both of them advertise the very same `PROTO-IP:0'. */
  start_address_validation (&aqm->receiver, queue->address);
  /* look for traffic for this queue */
  // TODO Check whether this makes any sense at all.
  /*schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
    queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT);*/
  /* might be our first queue, try launching DV learning */
  if (NULL == dvlearn_task)
    dvlearn_task = GNUNET_SCHEDULER_add_now (&start_dv_learn, NULL);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
handle_update_queue_message (void *cls,
                             const struct
                             GNUNET_TRANSPORT_UpdateQueueMessage *msg)
{
  struct TransportClient *tc = cls;
  struct Queue *target_queue = NULL;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    /* Without this we walk `details.communicator.queue_head' for a client
       whose union holds something else entirely. */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received queue update message for %u with q_len %llu and mtu %u\n",
              ntohl (msg->qid),
              (unsigned long long) GNUNET_ntohll (msg->q_len),
              ntohl (msg->mtu));
  for (target_queue = tc->details.communicator.queue_head;
       NULL != target_queue;
       target_queue = target_queue->next_client)
  {
    if (ntohl (msg->qid) == target_queue->qid)
      break;
  }
  if (NULL == target_queue)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Queue to update no longer exists! Discarding update.\n");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
 
  target_queue->nt = ntohl (msg->nt);
  target_queue->mtu = ntohl (msg->mtu);
  target_queue->cs = ntohl (msg->cs);
  target_queue->priority = ntohl (msg->priority);
  /* The update message indicates how many messages
   * the queue should be able to handle.
   */
  if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (msg->q_len))
    target_queue->unlimited_length = GNUNET_YES;
  else
    target_queue->unlimited_length = GNUNET_NO;
  target_queue->q_capacity += GNUNET_ntohll (msg->q_len);
  if (0 < target_queue->q_capacity)
    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                target_queue,
                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
handle_queue_create_ok (void *cls,
                        const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_STATISTICS_update (GST_stats,
                            "# Suggestions succeeded at communicator",
                            1,
                            GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Request #%u for communicator to create queue succeeded\n",
              (unsigned int) ntohs (cqr->request_id));
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
handle_queue_create_fail (
  void *cls,
  const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Request #%u for communicator to create queue failed\n",
              (unsigned int) ntohl (cqr->request_id));
  GNUNET_STATISTICS_update (GST_stats,
                            "# Suggestions failed in queue creation at communicator",
                            1,
                            GNUNET_NO);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
handle_suggest_cancel (void *cls, const struct ExpressPreferenceMessage *msg)
{
  struct TransportClient *tc = cls;
  struct PeerRequest *pr;
 
  if (CT_APPLICATION != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  pr = GNUNET_CONTAINER_multipeermap_get (tc->details.application.requests,
                                          &msg->peer);
  if (NULL == pr)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  (void) stop_peer_request (tc, &pr->pid, pr);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static void
hello_for_client_cb (void *cls,
                     const struct GNUNET_PeerIdentity *pid,
                     const char *uri)
{
  struct Queue *q;
  int pfx_len;
  const char *eou;
  char *address;
  (void) cls;
 
  eou = strstr (uri,
                "://");
  if ((NULL == eou) || (eou == uri))
  {
    /* @a uri comes from a HELLO some remote peer published. */
    GNUNET_break_op (0);
    return;
  }
  pfx_len = eou - uri;
  eou += 3;
  GNUNET_asprintf (&address,
                   "%.*s-%s",
                   pfx_len,
                   uri,
                   eou);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "hello for client %s\n",
              address);
 
  q = find_queue (pid, address);
  if (NULL == q)
  {
    suggest_to_connect (pid, address);
  }
  else
    start_address_validation (pid, address);
  GNUNET_free (address);
}
 
 
static void
handle_hello_for_client (void *cls,
                         const struct GNUNET_PEERSTORE_Record *record,
                         const char *emsg)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct PeerRequest *pr = cls;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_MessageHeader *hello;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "No identity given yet!\n");
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  hello = hello_from_record (record);
  if (NULL == hello)
  {
    /* MUST still ask for the next record: a bad one is not a reason to
       stall this monitor forever. */
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  if (0 == GNUNET_memcmp (&record->peer, my_identity))
  {
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
  if (NULL == parser)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "HELLO cannot be parsed!\n");
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "HELLO for `%s' could be parsed, iterating addresses...!\n",
              GNUNET_i2s (GNUNET_HELLO_parser_get_id (parser)));
  GNUNET_HELLO_parser_iterate (parser,
                               hello_for_client_cb,
                               NULL);
  GNUNET_HELLO_parser_free (parser);
  /* MUST ask for the next record, or this monitor stalls after one HELLO */
  GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
}
 
 
static void
hello_for_client_error_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}
 
 
static void
hello_for_client_sync_cb (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Done with initial PEERSTORE iteration during monitoring\n");
}
 
 
static void
start_peer_request_monitor (struct PeerRequest *pr)
{
  if (NULL != pr->nc)
    GNUNET_PEERSTORE_monitor_stop (pr->nc);
  /* Monitor only @e pid.  With NULL every application request sees every
     HELLO in PEERSTORE, so a client asking for one peer made us suggest a
     connection to -- and start an address validation for -- every peer we
     have ever heard of, once per request.  #try_to_bring_link_up() had the
     same bug and was already fixed the same way. */
  pr->nc =
    GNUNET_PEERSTORE_monitor_start (GST_cfg,
                                    GNUNET_YES,
                                    "peerstore",
                                    &pr->pid,
                                    GNUNET_PEERSTORE_HELLO_KEY,
                                    &hello_for_client_error_cb,
                                    NULL,
                                    &hello_for_client_sync_cb,
                                    NULL,
                                    &handle_hello_for_client,
                                    pr);
}
 
 
static void
suggest_retry_cb (void *cls)
{
  struct PeerRequest *pr = cls;
  struct VirtualLink *vl;
 
  pr->retry_task = NULL;
  vl = lookup_virtual_link (&pr->pid);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    /* The client has what it asked for.  Keep watching cheaply, and start
       over from the short interval when the link goes away again. */
    pr->retry_backoff = SUGGEST_RETRY_MIN;
    pr->retry_task = GNUNET_SCHEDULER_add_delayed (SUGGEST_RETRY_MAX,
                                                   &suggest_retry_cb,
                                                   pr);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Retrying to connect to %s, an application client wants it\n",
              GNUNET_i2s (&pr->pid));
  GNUNET_STATISTICS_update (GST_stats,
                            "# link setup retries for application clients",
                            1,
                            GNUNET_NO);
  /* Addresses we already track, queues we still have, and a fresh look in
     PEERSTORE. */
  try_to_bring_link_up (&pr->pid);
  /* ... plus a replay of what PEERSTORE has for this peer, which is the
     only way back once the validation state expired and the queues are
     gone. */
  start_peer_request_monitor (pr);
  pr->retry_backoff = GNUNET_TIME_randomized_backoff (pr->retry_backoff,
                                                      SUGGEST_RETRY_MAX);
  pr->retry_task = GNUNET_SCHEDULER_add_delayed (pr->retry_backoff,
                                                 &suggest_retry_cb,
                                                 pr);
}
 
 
static void
handle_suggest (void *cls, const struct ExpressPreferenceMessage *msg)
{
  struct TransportClient *tc = cls;
  const struct GNUNET_PeerIdentity *my_identity;
  struct PeerRequest *pr;
 
  if (CT_NONE == tc->type)
  {
    tc->type = CT_APPLICATION;
    tc->details.application.requests =
      GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
  }
  if (CT_APPLICATION != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Still waiting for own identity!\n");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client suggested we talk to %s with preference %d at rate %u\n",
              GNUNET_i2s (&msg->peer),
              (int) ntohl (msg->pk),
              (int) ntohl (msg->bw.value__));
  if (0 == GNUNET_memcmp (my_identity, &msg->peer))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Client suggested connection to ourselves, ignoring...\n");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  pr = GNUNET_new (struct PeerRequest);
  pr->tc = tc;
  pr->pid = msg->peer;
  pr->bw = msg->bw;
  pr->pk = ntohl (msg->pk);
  if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_put (
        tc->details.application.requests,
        &pr->pid,
        pr,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_break (0);
    GNUNET_free (pr);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  start_peer_request_monitor (pr);
  /* The monitor alone only ever fires again if the HELLO *changes*.  Keep
     asking for the link ourselves for as long as the client wants it. */
  pr->retry_backoff = SUGGEST_RETRY_MIN;
  pr->retry_task = GNUNET_SCHEDULER_add_delayed (pr->retry_backoff,
                                                 &suggest_retry_cb,
                                                 pr);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static int
check_request_hello_validation (void *cls,
                                const struct RequestHelloValidationMessage *m)
{
  (void) cls;
  GNUNET_MQ_check_zero_termination (m);
  return GNUNET_OK;
}
 
 
static void
handle_request_hello_validation (void *cls,
                                 const struct RequestHelloValidationMessage *m)
{
  struct TransportClient *tc = cls;
  struct Queue *q;
 
  q = find_queue (&m->peer, (const char *) &m[1]);
  if (NULL == q)
  {
    suggest_to_connect (&m->peer, (const char *) &m[1]);
  }
  else
    start_address_validation (&m->peer, (const char *) &m[1]);
  GNUNET_SERVICE_client_continue (tc->client);
}
 
 
static int
free_neighbour_cb (void *cls,
                   const struct GNUNET_PeerIdentity *pid,
                   void *value)
{
  struct Neighbour *neighbour = value;
 
  (void) cls;
  (void) pid;
  GNUNET_break (0);  // should this ever happen?
  free_neighbour (neighbour, GNUNET_YES);
 
  return GNUNET_OK;
}
 
 
static int
free_virtual_link_cb (void *cls,
                      const struct GNUNET_PeerIdentity *pid,
                      void *value)
{
  struct VirtualLink *vl = value;
 
  (void) cls;
  (void) pid;
  free_virtual_link (vl);
 
  return GNUNET_OK;
}
 
 
static int
free_dv_routes_cb (void *cls,
                   const struct GNUNET_PeerIdentity *pid,
                   void *value)
{
  struct DistanceVector *dv = value;
 
  (void) cls;
  (void) pid;
  free_dv_route (dv);
 
  return GNUNET_OK;
}
 
 
static int
free_validation_state_cb (void *cls,
                          const struct GNUNET_PeerIdentity *pid,
                          void *value)
{
  struct ValidationState *vs = value;
 
  (void) cls;
  (void) pid;
  free_validation_state (vs);
  return GNUNET_OK;
}
 
 
static int
free_pending_ack_cb (void *cls, const struct GNUNET_Uuid *key, void *value)
{
  struct PendingAcknowledgement *pa = value;
 
  (void) cls;
  (void) key;
  free_pending_acknowledgement (pa);
  return GNUNET_OK;
}
 
 
static int
free_ack_cummulator_cb (void *cls,
                        const struct GNUNET_PeerIdentity *pid,
                        void *value)
{
  struct AcknowledgementCummulator *ac = value;
 
  (void) cls;
  (void) pid;
  /* @e task is armed for the whole life of @a ac -- but
     #transmit_cummulative_ack_cb() clears it before re-arming, and it
     routes a message while it is clear.  #GNUNET_SCHEDULER_cancel()
     dereferences its argument unconditionally. */
  if (NULL != ac->task)
  {
    GNUNET_SCHEDULER_cancel (ac->task);
    ac->task = NULL;
  }
  GNUNET_free (ac);
  return GNUNET_OK;
}
 
 
static void
do_shutdown (void *cls)
{
  static int shutdown_done;
  struct LearnLaunchEntry *lle;
  struct PilsRequest *pr;
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "shutdown logic\n");
  if (GNUNET_YES == shutdown_done)
    return;   /* reachable both from #shutdown_task() and #client_disconnect_cb() */
  shutdown_done = GNUNET_YES;
  if (NULL != client_grace_task)
  {
    GNUNET_SCHEDULER_cancel (client_grace_task);
    client_grace_task = NULL;
  }
  if (NULL != nh)
  {
    GNUNET_NAT_unregister (nh);
    nh = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &free_neighbour_cb, NULL);
  /* Freeing a neighbour takes its virtual link with it, so whatever is
     left here is ownerless: a link we created from an inbound FLOW_CONTROL
     message that never got confirmed, kept alive only by its @e
     unconfirmed_timeout_task.  #GNUNET_SCHEDULER_shutdown() does not run
     that task, so leaving the link in place left the task armed against a
     map we destroy further down -- it fired afterwards and
     #free_virtual_link() called GNUNET_CONTAINER_multipeermap_remove() on
     NULL.  Drop them here, while every structure they touch is still
     alive. */
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &free_virtual_link_cb,
                                         NULL);
  if (NULL != validation_task)
  {
    GNUNET_SCHEDULER_cancel (validation_task);
    validation_task = NULL;
  }
  if (NULL != dvlearn_task)
  {
    GNUNET_SCHEDULER_cancel (dvlearn_task);
    dvlearn_task = NULL;
  }
  if (NULL != burst_task)
  {
    GNUNET_SCHEDULER_cancel (burst_task);
    burst_task = NULL;
  }
  if (NULL != burst_timeout_task)
  {
    GNUNET_SCHEDULER_cancel (burst_timeout_task);
    burst_timeout_task = NULL;
  }
  burst_running = GNUNET_NO;
  GNUNET_CONTAINER_multishortmap_destroy (dvlearn_map);
  dvlearn_map = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (dv_routes, &free_dv_routes_cb, NULL);
  GNUNET_CONTAINER_multipeermap_destroy (dv_routes);
  dv_routes = NULL;
  if (NULL != GST_stats)
  {
    GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
    GST_stats = NULL;
  }
  if (NULL != GST_my_hello)
  {
    GNUNET_HELLO_builder_free (GST_my_hello);
    GST_my_hello = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (ack_cummulators,
                                         &free_ack_cummulator_cb,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (ack_cummulators);
  ack_cummulators = NULL;
  GNUNET_CONTAINER_multiuuidmap_iterate (pending_acks,
                                         &free_pending_ack_cb,
                                         NULL);
  GNUNET_CONTAINER_multiuuidmap_destroy (pending_acks);
  pending_acks = NULL;
  GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (neighbours));
  GNUNET_CONTAINER_multipeermap_destroy (neighbours);
  neighbours = NULL;
  GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (links));
  GNUNET_CONTAINER_multipeermap_destroy (links);
  links = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (backtalkers,
                                         &free_backtalker_cb,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (backtalkers);
  backtalkers = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (validation_map,
                                         &free_validation_state_cb,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (validation_map);
  validation_map = NULL;
  GNUNET_CONTAINER_heap_destroy (validation_heap);
  validation_heap = NULL;
  GNUNET_CONTAINER_multihashmap_destroy (revalidation_map);
  revalidation_map = NULL;
  while (NULL != ir_head)
    free_incoming_request (ir_head);
  GNUNET_assert (0 == ir_total);
  while (NULL != (lle = lle_head))
  {
    GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
    GNUNET_free (lle);
  }
  while (NULL != (pr = pils_requests_head))
  {
    GNUNET_CONTAINER_DLL_remove (pils_requests_head,
                                 pils_requests_tail,
                                 pr);
    if (NULL != pr->op)
      GNUNET_PILS_cancel (pr->op);
    GNUNET_free (pr);
  }
  if (NULL != pils_feed_task)
  {
    GNUNET_SCHEDULER_cancel (pils_feed_task);
    pils_feed_task = NULL;
  }
  if (NULL != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
  }
  if (NULL != peerstore)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Disconnecting from PEERSTORE service\n");
    GNUNET_PEERSTORE_disconnect (peerstore);
    peerstore = NULL;
  }
  GNUNET_SCHEDULER_shutdown ();
}
 
 
static const char*
get_client_type_name (enum ClientType type)
{
  switch (type)
  {
  case CT_CORE:
    return "CORE";
  case CT_MONITOR:
    return "MONITOR";
  case CT_COMMUNICATOR:
    return "COMMUNICATOR";
  case CT_APPLICATION:
    return "APPLICATION";
  default:
    return "UNKNOWN";
  }
}
 
 
static void
drop_remaining_clients (void *cls)
{
  client_grace_task = NULL;
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Client did not disconnect within the shutdown grace period, "
                "dropping it: %s\n",
                get_client_type_name (tc->type));
  }
  /* We use #GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, so the service will NOT
     drop clients for us.  Without this we would wait forever for them to
     leave on their own and never reach #do_shutdown(). */
  GNUNET_SERVICE_shutdown (GST_service);
  /* Dropping the clients ran #client_disconnect_cb() for each of them, so
     #do_shutdown() has normally run by now; it is idempotent, and this
     covers the case where there was nothing left to drop. */
  do_shutdown (cls);
}
 
 
static void
shutdown_task (void *cls)
{
  in_shutdown = GNUNET_YES;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Shutdown task executed\n");
  if (NULL != clients_head)
  {
    for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Waiting for client to disconnect: %s\n",
                  get_client_type_name (tc->type));
    }
    /* Give them a chance to shut down cleanly; #client_disconnect_cb() calls
       #do_shutdown() once the last one is gone, and #do_shutdown() cancels
       this task. */
    client_grace_task =
      GNUNET_SCHEDULER_add_delayed (SHUTDOWN_CLIENT_GRACE_PERIOD,
                                    &drop_remaining_clients,
                                    cls);
    return;
  }
  do_shutdown (cls);
}
 
 
struct UpdateHelloFromPidCtx
{
  struct GNUNET_PEERSTORE_StoreHelloContext *sc;
};
 
static void
update_hello_from_pid_change_cb (void *cls, int success)
{
  struct UpdateHelloFromPidCtx *pc = cls;
 
  /* NOTE: @a success is GNUNET_OK even when #hello_add_iter() decided not to
     store anything because PEERSTORE already holds a HELLO that expires
     later; the API reports the desired state, not whether it wrote.  So this
     says "we have a current HELLO on record", not "we just wrote one". */
  if (GNUNET_OK != success)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to store our new hello with peerstore\n");
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Our hello is current in peerstore\n");
  GNUNET_free (pc);
}
 
 
void
print_address_list (void *cls,
                    const struct GNUNET_PeerIdentity *pid,
                    const char *uri)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%s\n", uri);
}
 
 
static void
pils_pid_change_cb (void *cls,
                    const struct GNUNET_HELLO_Parser *parser,
                    const struct GNUNET_HashCode *hash)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_MQ_Envelope *env;
  const struct GNUNET_MessageHeader *msg;
  struct UpdateHelloFromPidCtx *sc;
  struct GNUNET_HELLO_Builder *nbuilder;
  struct GNUNET_PeerIdentity npid;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  if (NULL == GST_my_hello)
    GST_my_hello = GNUNET_HELLO_builder_new ();
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My current identity is `%s'\n",
              GNUNET_i2s_full (my_identity));
  nbuilder = GNUNET_HELLO_builder_from_parser (parser,
                                               &npid);
  if (GNUNET_NO ==
      GNUNET_HELLO_builder_address_list_cmp (GST_my_hello, nbuilder))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "New PID from PILS is derived from address list inconsistent with ours. Ignoring...\n");
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Proposed address list:\n");
    GNUNET_HELLO_builder_iterate (nbuilder, &print_address_list, NULL);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Current address list:\n");
    GNUNET_HELLO_builder_iterate (GST_my_hello, &print_address_list, NULL);
    GNUNET_HELLO_builder_free (nbuilder);
    return;
  }
  GNUNET_HELLO_builder_free (GST_my_hello);
  GST_my_hello = nbuilder;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My new identity is `%s'\n",
              GNUNET_i2s_full (my_identity));
  env = GNUNET_HELLO_parser_to_env (parser);
  msg = GNUNET_MQ_env_get_msg (env);
  sc = GNUNET_new (struct UpdateHelloFromPidCtx);
  sc->sc = GNUNET_PEERSTORE_hello_add (peerstore,
                                       msg,
                                       update_hello_from_pid_change_cb,
                                       sc);
  GNUNET_free (env);
}
 
 
static void
run (void *cls,
     const struct GNUNET_CONFIGURATION_Handle *c,
     struct GNUNET_SERVICE_Handle *service)
{
  (void) cls;
  /* setup globals */
  GST_service = service;
  hello_mono_time = GNUNET_TIME_absolute_get_monotonic (c);
  in_shutdown = GNUNET_NO;
  GST_cfg = c;
  backtalkers = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
  pending_acks = GNUNET_CONTAINER_multiuuidmap_create (32768, GNUNET_YES);
  ack_cummulators = GNUNET_CONTAINER_multipeermap_create (256, GNUNET_YES);
  neighbours = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
  links = GNUNET_CONTAINER_multipeermap_create (512, GNUNET_YES);
  dv_routes = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
  dvlearn_map = GNUNET_CONTAINER_multishortmap_create (2 * MAX_DV_LEARN_PENDING,
                                                       GNUNET_YES);
  validation_map = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
  revalidation_map = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_YES);
  validation_heap =
    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  // TODO check for all uses of GST_my_hello that it is not used uninitialized
  use_burst = GNUNET_CONFIGURATION_get_value_yesno (GST_cfg,
                                                    "transport",
                                                    "USE_BURST_NAT");
  if (GNUNET_SYSERR == use_burst)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Could not configure burst nat use. Default to no.\n");
  GST_my_hello = GNUNET_HELLO_builder_new ();
  GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  peerstore = GNUNET_PEERSTORE_connect (GST_cfg);
  nh = GNUNET_NAT_register (GST_cfg,
                            "transport",
                            0,
                            0,
                            NULL,
                            0,
                            NULL,
                            NULL,
                            NULL);
  if (NULL == peerstore)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  pils = GNUNET_PILS_connect (GST_cfg,
                              pils_pid_change_cb,
                              NULL);          // FIXME we need to wait for
  // our first peer id before
  // we can start the service
  // completely - PILS in turn
  // waits for the first
  // addresses from the
  // communicators in order to
  // be able to generate a
  // peer id
  if (NULL == pils)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  /* Decapsulate DV box ephemeral keys ourselves.  #handle_dv_box() needs
     the key material while it still has the box, which points into the
     communicator's inbound message and is gone the moment the handler
     returns -- so the asynchronous answer arrived to a dangling @a dvb. */
  if (GNUNET_OK !=
      GNUNET_PILS_enable_private_key (pils))
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to load our private key, "
                   "cannot open DV boxes addressed to us\n"));
}
 
 
GNUNET_SERVICE_MAIN (
  GNUNET_OS_project_data_gnunet (),
  "transport",
  GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN,
  &run,
  &client_connect_cb,
  &client_disconnect_cb,
  NULL,
  /* communication with applications */
  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),
  /* communication with core */
  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),
  /* communication with communicators */
  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),
  /* communication with monitors */
  GNUNET_MQ_hd_fixed_size (monitor_start,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START,
                           struct GNUNET_TRANSPORT_MonitorStart,
                           NULL),
  GNUNET_MQ_hd_fixed_size (link_list_request,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_REQUEST,
                           struct GNUNET_TRANSPORT_LinkListRequest,
                           NULL),
  GNUNET_MQ_handler_end ());
 
 
/* end of file gnunet-service-transport.c */

UNCONFIRMED_LINK_TIMEOUT

#define UNCONFIRMED_LINK_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

How long do we keep a virtual link that only exists because some peer sent us a FLOW_CONTROL message, without it ever becoming confirmed?

Definition at line 109 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 116 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 130 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 136 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 142 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 148 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 158 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 164 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 174 of file gnunet-service-transport.c.

CORE_FC_STALL_TIMEOUT

#define CORE_FC_STALL_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)

How long do we wait for CORE to return the flow control credit for the messages we handed it before we give up on them?

Only the per-message ACK to the communicator is delayed this long; the communicator itself keeps being read (see finish_handling_raw_message()), so overshooting no longer takes every other peer down with it. What is left to bound is a CORE that has gone silent throttling the flow-control-capable communicators indefinitely. A RECV_OK is a local IPC round trip against a CORE that processes our messages synchronously, so this is roughly three orders of magnitude of headroom over the healthy case while still being short enough that a wedged CORE does not cost a peer a minute of throughput.

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

MAX_STALLED_CMCS

#define MAX_STALLED_CMCS   (4 * RECV_WINDOW_SIZE)

How many messages may wait on VirtualLink::core_recv_window before we stop deferring their flow control ACKs?

The payload of a stalled message has already been handed to CORE; the ‘struct CommunicatorMessageContext’ left behind only carries the ACK we are withholding. Dropping the oldest one therefore costs nothing but the backpressure it expressed, which is a far better trade than letting the list grow without bound now that the client is no longer stalled along with it.

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

MAX_DV_HOPS_ALLOWED

#define MAX_DV_HOPS_ALLOWED   16

Maximum DV distance allowed ever.

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

MAX_DV_PICK_TRIES

#define MAX_DV_PICK_TRIES   1000

How often pick_random_dv_hops() may redraw before settling for the paths it has.

Weighted rejection sampling converges in a handful of draws; past this it is a set it cannot sample distinctly.

Definition at line 225 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 231 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 236 of file gnunet-service-transport.c.

PILS_FEED_ADDRESSES_DELAY

#define PILS_FEED_ADDRESSES_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3)

Delay between added/removed addresses and PILS feed call.

Introduced to handle cases with high address churn across communicators (startup, location change etc)

Definition at line 244 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 252 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 259 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 265 of file gnunet-service-transport.c.

MIN_ACK_WAIT_DURATION

#define MIN_ACK_WAIT_DURATION    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 10)

Lower bound on the RTT estimate we are willing to derive a retransmission deadline from.

‘struct PerformanceData::aged_rtt’ is an exponential average over observed round trip times with no floor of its own, and over a UNIX domain socket or a loopback queue the observed RTT is a few microseconds. transmit_on_queue() turns that straight into ‘next_attempt’, so the message it just sent is eligible again on the very next pass – and it arms that pass itself, unconditionally, with GNUNET_TIME_UNIT_ZERO. The result is a tight retransmission loop that saturates a core and drowns the communicator ("Dropping message: transport is too slow").

Compare MIN_FC_RETRANSMIT_DELAY, which exists for exactly the same reason on the flow control path.

Definition at line 284 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 292 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 299 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 306 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 313 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 319 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 325 of file gnunet-service-transport.c.

MAX_REASSEMBLY_CONTEXTS

#define MAX_REASSEMBLY_CONTEXTS   32

Maximum number of messages we are willing to reassemble in parallel for a single virtual link.

Each context is sized from the sender's ‘msg_size’ field (up to 64k) and lives for REASSEMBLY_EXPIRATION, so this must be bounded.

Definition at line 334 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 340 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 346 of file gnunet-service-transport.c.

WANTED_VALIDATION_CHALLENGE_FREQ

#define WANTED_VALIDATION_CHALLENGE_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

What is the slowest rate at which we send challenges to a peer that an application client explicitly asked for and that we have no confirmed link to? Somebody is waiting for this one, so a day is not an option.

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

SUGGEST_RETRY_MIN

#define SUGGEST_RETRY_MIN    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

How soon after an application asked us for a peer do we retry bringing the link up for the first time?

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

SUGGEST_RETRY_MAX

#define SUGGEST_RETRY_MAX    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

What is the slowest rate at which we retry bringing up a link that an application client explicitly asked for? Unlike a peer we merely heard about, somebody is waiting for this one, so this is far below MAX_VALIDATION_CHALLENGE_FREQ.

Definition at line 370 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 378 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 385 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 391 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 396 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 402 of file gnunet-service-transport.c.

NEIGHBOUR_LIVENESS_TIMEOUT

#define NEIGHBOUR_LIVENESS_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)

How long may a direct neighbour stay completely silent before we stop believing that its queues work, regardless of what the communicator that owns them tells us?

We normally learn that a queue died because the communicator sends us a GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN. If it does not (because it is buggy or wedged), the only other bound is the expiry of the last successful address validation – i.e. ADDRESS_VALIDATION_LIFETIME, four hours – during all of which CORE would keep believing it is connected.

This is a backstop, not the primary detector: it is deliberately several times GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, which is what the communicators themselves use, so that under normal operation it never fires first. When it does fire, a communicator misbehaved.

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

FC_KEEPALIVE_INTERVAL

#define FC_KEEPALIVE_INTERVAL

Value:

        GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, \
                                     2)

How long may a confirmed virtual link go without us sending anything on it before we transmit an otherwise unnecessary FLOW_CONTROL message, purely so that the peer at the other end keeps seeing traffic from us?

check_link_down() drops a neighbour that has said nothing for NEIGHBOUR_LIVENESS_TIMEOUT, which silently assumes that something generates traffic on a healthy link. Nothing in this service did: FC is event-driven and handle_flow_control() deliberately stops retransmitting once both ends agree on the window, which on an idle link is immediately. A link with no application traffic therefore fell completely silent and then tore itself down on the very timer meant to catch broken ones.

MUST stay comfortably below NEIGHBOUR_LIVENESS_TIMEOUT so that a couple of lost keepalives are not enough to trip it.

It MUST also stay comfortably below GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, which is what the communicators use to decide that a connection went idle (‘Queue p was idle for s, disconnecting’ in the TCP communicator). This used to be NEIGHBOUR_LIVENESS_TIMEOUT / 3, which is exactly that timeout, and the race went the wrong way every time: the queue's idle deadline is refreshed when the peer's FC arrives, ours is armed a moment later when handle_flow_control() has finished processing it, so the communicator's five minutes were always up first. On a link with no CORE session to keep it busy that tore down a working TCP connection every five minutes. Deriving it from the timeout it has to beat keeps the two from drifting into each other again.

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

MIN_ADDRESS_REFRESH_INTERVAL

#define MIN_ADDRESS_REFRESH_INTERVAL    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

How often are we willing to re-sign and re-store one of our own addresses in PEERSTORE, no matter how short a lifetime the communicator that owns it claims? See peerstore_store_own_cb().

Definition at line 461 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 470 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 478 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 486 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 493 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 498 of file gnunet-service-transport.c.

RTT_DIFF

#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.

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

SHUTDOWN_CLIENT_GRACE_PERIOD

#define SHUTDOWN_CLIENT_GRACE_PERIOD    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

How long do we wait during shutdown for our clients to disconnect on their own before we drop them? We run with GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, so nobody drops them for us and a single wedged client would otherwise keep us alive forever.

Definition at line 514 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

cls	closure
next_hop	next hop of the DV path
hdr	encapsulated message, technically a struct TransportDFBoxMessage
options	options of the original message

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

{
  CT_NONE = 0,
 
  CT_CORE = 1,
 
  CT_MONITOR = 2,
 
  CT_COMMUNICATOR = 3,
 
  CT_APPLICATION = 4
};

RouteMessageOptions

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

{
  RMO_NONE = 0,
 
  RMO_DV_ALLOWED = 1,
 
  RMO_UNCONFIRMED_ALLOWED = 2,
 
  RMO_ANYTHING_GOES = (RMO_DV_ALLOWED | RMO_UNCONFIRMED_ALLOWED),
 
  RMO_REDUNDANT = 4
};

PendingMessageType

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

{
  PMT_CORE = 0,
 
  PMT_FRAGMENT_BOX = 1,
 
  PMT_RELIABILITY_BOX = 2,
 
  PMT_DV_BOX = 3
};

Function Documentation

GNUNET_static_assert() [1/9]

GNUNET_NETWORK_STRUCT_END GNUNET_static_assert

(

sizeof(struct TransportGlobalNattedAddress)

= =4

)

GNUNET_static_assert() [2/9]

GNUNET_static_assert

(

sizeof(struct TransportFlowControlMessage)

= =60

)

GNUNET_static_assert() [3/9]

GNUNET_static_assert

(

sizeof(struct TransportDVBoxMessage)

= =86

)

GNUNET_static_assert() [4/9]

GNUNET_static_assert

(

sizeof(struct TransportDVLearnMessage)

= =152

)

GNUNET_static_assert() [5/9]

GNUNET_static_assert

(

sizeof(struct TransportFragmentBoxMessage)

= =32

)

GNUNET_static_assert() [6/9]

GNUNET_static_assert

(

sizeof(struct TransportReliabilityBoxMessage)

= =24

)

GNUNET_static_assert() [7/9]

GNUNET_static_assert

(

sizeof(struct TransportReliabilityAckMessage)

= =8

)

GNUNET_static_assert() [8/9]

GNUNET_static_assert

(

sizeof(struct TransportValidationChallengeMessage)

= =48

)

GNUNET_static_assert() [9/9]

GNUNET_static_assert

(

sizeof(struct TransportValidationResponseMessage)

= =120

)

sign_by_my_identity()

static enum GNUNET_GenericReturnValue sign_by_my_identity ( const struct GNUNET_CRYPTO_SignaturePurpose *  purpose, struct GNUNET_CRYPTO_EddsaSignature *  sig  )

static

Sign purpose with the private key of our current peer identity.

This is the synchronous counterpart of GNUNET_PILS_sign_by_peer_identity(): GNUNET_PILS_enable_private_key() gave us the key itself, so the signature is available before we return instead of after a round-trip through the PILS service.

Prefer it everywhere. Signing asynchronously means suspending whatever the signature was needed for until the scheduler comes back, and the state that has to survive until then is state we do not control: a struct CommunicatorMessageContext keeps its communicator client blocked until finish_cmc_handling() runs, and a communicator we stop reading from does not stop receiving – it starts discarding ("transport is too slow", see GNUNET_TRANSPORT_communicator_receive()). So one signature that PILS is slow to answer, or never answers because the connection broke, does not delay one message: it silently drops every peer that communicator carries.

Parameters

	purpose	what to sign (size, purpose and data)
[out]	sig	where to write the signature

Returns

GNUNET_OK on success, GNUNET_SYSERR if we have no usable private key for our current peer identity

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

{
  const struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 
  my_private_key = GNUNET_PILS_get_private_key (pils);
  if (NULL == my_private_key)
  {
    /* #run() enables local key access, so this means the key on disk does
       not match the identity PILS announced, or no identity is known yet. */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "No private key for our peer identity, cannot sign\n");
    GNUNET_STATISTICS_update (GST_stats,
                              "# signatures failed (no private key)",
                              1,
                              GNUNET_NO);
    return GNUNET_SYSERR;
  }
  return GNUNET_CRYPTO_eddsa_sign_ (my_private_key, purpose, sig);
}

References GNUNET_CRYPTO_eddsa_sign_(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_PILS_get_private_key(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GST_stats, my_private_key, and pils.

Referenced by forward_dv_learn(), handle_validation_challenge(), pils_sign_address(), sign_ephemeral(), and start_dv_learn().

Here is the call graph for this function:

Here is the caller graph for this function:

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

{
  struct GNUNET_TIME_Absolute now;
 
  now = GNUNET_TIME_absolute_get ();
  return now.abs_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us / 15;
}

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

ir	data structure to release

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

{
  GNUNET_CONTAINER_DLL_remove (ir_head, ir_tail, ir);
  GNUNET_assert (ir_total > 0);
  ir_total--;
  if (NULL != ir->nc)
    GNUNET_PEERSTORE_monitor_stop (ir->nc);
  ir->nc = NULL;
  GNUNET_free (ir);
}

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

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

pa	data structure to release

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

{
  struct Queue *q = pa->queue;
  struct PendingMessage *pm = pa->pm;
  struct DistanceVectorHop *dvh = pa->dvh;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "free_pending_acknowledgement\n");
  if (NULL != q)
  {
    GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa);
    pa->queue = NULL;
  }
  if (NULL != pm)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message\n");
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message %" PRIu64 "\n",
                pm->logging_uuid);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message %u\n",
                pm->pmt);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "remove pa from message %s\n",
                GNUNET_uuid2s (&pa->ack_uuid.value));
    GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
    pa->pm = NULL;
  }
  if (NULL != dvh)
  {
    GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
    pa->dvh = NULL;
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multiuuidmap_remove (pending_acks,
                                                       &pa->ack_uuid.value,
                                                       pa));
  GNUNET_free (pa);
}

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, PendingMessage::logging_uuid, DistanceVectorHop::pa_head, PendingMessage::pa_head, DistanceVectorHop::pa_tail, PendingMessage::pa_tail, pending_acks, PendingAcknowledgement::pm, PendingMessage::pmt, q, queue(), PendingAcknowledgement::queue, and AcknowledgementUUIDP::value.

Referenced by free_fragment_tree(), free_pending_ack_cb(), free_pending_message(), 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

root	root of the tree to free

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

{
  struct PendingMessage *frag;
 
  while (NULL != (frag = root->head_frag))
  {
    struct PendingAcknowledgement *pa;
 
    free_fragment_tree (frag);
    /* Release them: a `struct PendingAcknowledgement' whose @e pm is gone
       can never do anything useful again -- handle_acknowledged() would
       just free it -- but it stays in #pending_acks, and only an ACK that
       may never come takes it out.  Merely detaching it here leaked one
       entry per fragment that was not acknowledged before its message went
       away, which on a lossy link is unbounded growth. */
    while (NULL != (pa = frag->pa_head))
      free_pending_acknowledgement (pa);
    GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag, frag);
    if (NULL != frag->qe)
    {
      GNUNET_assert (frag == frag->qe->pm);
      frag->qe->pm = NULL;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Free frag %p\n",
                frag);
    GNUNET_free (frag);
  }
}

References free_fragment_tree(), free_pending_acknowledgement(), GNUNET_assert, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, PendingMessage::head_frag, PendingMessage::pa_head, QueueEntry::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

pm	the pending message to free

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

{
  struct TransportClient *tc = pm->client;
  struct VirtualLink *vl = pm->vl;
  struct PendingAcknowledgement *pa;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Freeing pm %p\n",
              pm);
  if (NULL != tc)
  {
    GNUNET_CONTAINER_MDLL_remove (client,
                                  tc->details.core.pending_msg_head,
                                  tc->details.core.pending_msg_tail,
                                  pm);
  }
  if ((NULL != vl) && (NULL == pm->frag_parent))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Removing pm %" PRIu64 "\n",
                pm->logging_uuid);
    GNUNET_CONTAINER_MDLL_remove (vl,
                                  vl->pending_msg_head,
                                  vl->pending_msg_tail,
                                  pm);
  }
  else if (NULL != pm->frag_parent && PMT_DV_BOX != pm->pmt)
  {
    struct PendingMessage *root = pm->frag_parent;
 
    while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
      root = root->frag_parent;
 
    root->frag_count--;
  }
  /* Same as in #free_fragment_tree(): the message these acknowledgements
     belong to is going away, so they are garbage rather than orphans. */
  while (NULL != (pa = pm->pa_head))
    free_pending_acknowledgement (pa);
 
  free_fragment_tree (pm);
  if (NULL != pm->qe)
  {
    GNUNET_assert (pm == pm->qe->pm);
    pm->qe->pm = NULL;
  }
  if (NULL != pm->bpm)
  {
    free_fragment_tree (pm->bpm);
    /* @e bpm is released with GNUNET_free() rather than through
       #free_pending_message(), so nothing here ever unlinked the
       acknowledgements attached to the box itself -- only those of its
       fragments, via the call above.  They kept @e pm pointing into the
       block we are about to release, and #handle_acknowledged() follows
       that pointer when the ACK finally arrives. */
    while (NULL != (pa = pm->bpm->pa_head))
      free_pending_acknowledgement (pa);
    if (NULL != pm->bpm->qe)
    {
      struct QueueEntry *qe = pm->bpm->qe;
 
      qe->pm = NULL;
    }
    GNUNET_free (pm->bpm);
  }
 
  GNUNET_free (pm);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Freeing pm done\n");
}

References PendingMessage::bpm, PendingMessage::client, PendingMessage::frag_count, PendingMessage::frag_parent, free_fragment_tree(), free_pending_acknowledgement(), GNUNET_assert, GNUNET_CONTAINER_MDLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, PendingMessage::logging_uuid, PendingMessage::pa_head, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, PendingAcknowledgement::pm, QueueEntry::pm, PendingMessage::pmt, PMT_DV_BOX, qe, PendingMessage::qe, tc, and PendingMessage::vl.

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

rc	data structure to free

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

{
  struct VirtualLink *vl = rc->virtual_link;
 
  GNUNET_assert (rc == GNUNET_CONTAINER_heap_remove_node (rc->hn));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap32_remove (vl->reassembly_map,
                                                         rc->msg_uuid.uuid,
                                                         rc));
  GNUNET_free (rc);
}

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

cls	a struct Neighbour

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

{
  struct VirtualLink *vl = cls;
  struct ReassemblyContext *rc;
 
  vl->reassembly_timeout_task = NULL;
  while (NULL != (rc = GNUNET_CONTAINER_heap_peek (vl->reassembly_heap)))
  {
    if (0 == GNUNET_TIME_absolute_get_remaining (rc->reassembly_timeout)
        .rel_value_us)
    {
      free_reassembly_context (rc);
      continue;
    }
    GNUNET_assert (NULL == vl->reassembly_timeout_task);
    vl->reassembly_timeout_task =
      GNUNET_SCHEDULER_add_at (rc->reassembly_timeout,
                               &reassembly_cleanup_task,
                               vl);
    return;
  }
}

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

cls	NULL
key	unused
value	a struct ReassemblyContext to free

Returns

GNUNET_OK (continue iteration)

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

{
  struct ReassemblyContext *rc = value;
 
  (void) cls;
  (void) key;
  free_reassembly_context (rc);
  return GNUNET_OK;
}

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:

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.

Send ACK to communicator (if requested), resume its client and free cmc.

Parameters

cmc	context for which we are done handling the message
free_cmc	should cmc be released?
cmc	context for which we are done handling the message
cmc	context for which we are done handling the message
free_cmc	GNUNET_YES to release cmc, GNUNET_NO if the caller still owns it

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

{
  send_cmc_ack (cmc);
  resume_cmc_client (cmc);
  if (GNUNET_YES == free_cmc)
  {
    GNUNET_free (cmc);
  }
}

References GNUNET_free, GNUNET_YES, resume_cmc_client(), and send_cmc_ack().

Referenced by demultiplex_with_cmc(), finish_cmc_handling(), finish_handling_raw_message(), handle_raw_message(), and release_stalled_cmc().

Here is the call graph for this function:

Here is the caller graph for this function:

release_stalled_cmc()

static void release_stalled_cmc ( struct VirtualLink *  vl, struct CommunicatorMessageContext *  cmc  )

static

Take cmc off the list of messages waiting on vl's CORE receive window, release the flow control credit we were withholding and free it.

Parameters

vl	virtual link cmc is queued on
cmc	context to release

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

{
  GNUNET_CONTAINER_DLL_remove (vl->cmc_head, vl->cmc_tail, cmc);
  GNUNET_assert (0 < vl->cmc_count);
  vl->cmc_count--;
  finish_cmc_handling_with_continue (cmc, GNUNET_YES);
}

References VirtualLink::cmc_count, VirtualLink::cmc_head, VirtualLink::cmc_tail, finish_cmc_handling_with_continue(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, and GNUNET_YES.

Referenced by core_fc_stalled(), finish_handling_raw_message(), free_virtual_link(), handle_client_recv_ok(), and resume_communicators().

Here is the call graph for this function:

Here is the caller graph for this function:

free_burst_cls()

static void free_burst_cls ( struct GNUNET_StartBurstCls *  sb_cls )

static

Release a burst closure, detaching it from its virtual link and from the scheduled burst_task (if that is the task the closure belongs to).

Parameters

sb_cls

closure to release

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

{
  struct VirtualLink *vl = sb_cls->vl;
 
  if (burst_task_cls == sb_cls)
  {
    if (NULL != burst_task)
    {
      GNUNET_SCHEDULER_cancel (burst_task);
      burst_task = NULL;
    }
    burst_task_cls = NULL;
  }
  if ((NULL != vl) && (vl->sb_cls == sb_cls))
    vl->sb_cls = NULL;
  GNUNET_free (sb_cls);
}

References burst_task, burst_task_cls, GNUNET_free, GNUNET_SCHEDULER_cancel(), VirtualLink::sb_cls, and GNUNET_StartBurstCls::vl.

Referenced by check_for_burst_address(), free_virtual_link(), queue_burst(), and start_burst().

Here is the call graph for this function:

Here is the caller graph for this function:

send_ok_to_client()

static void send_ok_to_client ( struct TransportClient *  tc, const struct GNUNET_PeerIdentity *  pid  )

static

Return one unit of send window credit for pid to tc.

GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK is the only way a CORE client ever learns that it may hand us another message for a peer: the client side (SEND_WINDOW_SIZE in transport_api_core.c) decrements a per-peer window on every send and only handle_send_ok() ever raises it again. So every SEND we accept has to be answered exactly once, whatever became of the message – it is a window, not a delivery confirmation ("in either case, it is now OK for this client to send us another message for the given peer", see ‘struct SendOkMessage’). Swallow one and the client loses that slot for good; swallow SEND_WINDOW_SIZE of them and it can never send to that peer again, with nothing to tell it why.

Parameters

tc	client to credit, may be NULL (message was not from a client)
pid	peer the credit is for

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

{
  struct GNUNET_MQ_Envelope *env;
  struct SendOkMessage *so_msg;
 
  if (NULL == tc)
    return;
  env = GNUNET_MQ_msg (so_msg, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
  so_msg->peer = *pid;
  GNUNET_MQ_send (tc->mq, env);
}

References env, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK, GNUNET_MQ_msg, GNUNET_MQ_send(), SendOkMessage::peer, and tc.

Referenced by credit_client(), and handle_client_send().

Here is the call graph for this function:

Here is the caller graph for this function:

credit_client()

static void credit_client ( struct PendingMessage *  pm )

static

Return the send window credit that pm's client is owed, at most once for pm.

A top-level message can reach more than one place that owes the credit – it is credited when it is handed to a queue, and its completion path may run afterwards, it may be picked up again for retransmission, and its link may be freed underneath it. The window would grow past SEND_WINDOW_SIZE if any two of those paid out for the same message.

Parameters

pm	top-level pending message whose credit to return

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

{
  if ((NULL == pm->client) || (GNUNET_YES == pm->client_credited))
    return;
  pm->client_credited = GNUNET_YES;
  send_ok_to_client (pm->client, &pm->vl->target);
}

References PendingMessage::client, PendingMessage::client_credited, GNUNET_YES, send_ok_to_client(), VirtualLink::target, and PendingMessage::vl.

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

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

vl	link data to free

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

{
  struct PendingMessage *pm;
  struct CoreSentContext *csc;
  struct CommunicatorMessageContext *cmc;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "free virtual link %p\n",
              vl);
 
  /* Communicators that are blocked on CORE flow control for this link MUST
     be resumed here.  Otherwise their `struct CommunicatorMessageContext's
     leak and -- worse -- those clients never get their
     GNUNET_SERVICE_client_continue() and stall forever. */
  while (NULL != (cmc = vl->cmc_head))
    release_stalled_cmc (vl, cmc);
  if (NULL != vl->core_fc_stall_task)
  {
    GNUNET_SCHEDULER_cancel (vl->core_fc_stall_task);
    vl->core_fc_stall_task = NULL;
  }
 
  if (NULL != vl->reassembly_map)
  {
    GNUNET_CONTAINER_multihashmap32_iterate (vl->reassembly_map,
                                             &free_reassembly_cb,
                                             NULL);
    GNUNET_CONTAINER_multihashmap32_destroy (vl->reassembly_map);
    vl->reassembly_map = NULL;
    GNUNET_CONTAINER_heap_destroy (vl->reassembly_heap);
    vl->reassembly_heap = NULL;
  }
  if (NULL != vl->reassembly_timeout_task)
  {
    GNUNET_SCHEDULER_cancel (vl->reassembly_timeout_task);
    vl->reassembly_timeout_task = NULL;
  }
  while (NULL != (pm = vl->pending_msg_head))
  {
    /* These never got transmitted, so #completed_pending_message() will not
       run for them and nobody else answers their SEND either.  Return the
       window credit anyway: CORE keeps its `struct Neighbour' -- and thus
       the window -- until it sees our DISCONNECT, and #handle_client_send()
       deliberately tolerates a SEND for a link that is already gone, so a
       client can easily still be sending while we free this. */
    credit_client (pm);
    free_pending_message (pm);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (links, &vl->target, vl));
  if (NULL != vl->visibility_task)
  {
    GNUNET_SCHEDULER_cancel (vl->visibility_task);
    vl->visibility_task = NULL;
  }
  if (NULL != vl->fc_retransmit_task)
  {
    GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
    vl->fc_retransmit_task = NULL;
  }
  while (NULL != (csc = vl->csc_head))
  {
    GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, csc);
    GNUNET_assert (vl == csc->vl);
    csc->vl = NULL;
  }
  if (NULL != vl->unconfirmed_timeout_task)
  {
    GNUNET_SCHEDULER_cancel (vl->unconfirmed_timeout_task);
    vl->unconfirmed_timeout_task = NULL;
  }
  if (NULL != vl->ic)
  {
    /* the closure of this iteration is @e sb_cls, released just below */
    GNUNET_PEERSTORE_iteration_stop (vl->ic);
    vl->ic = NULL;
  }
  if (NULL != vl->sb_cls)
  {
    /* Cancels #burst_task if that task's closure is ours: it would
       otherwise run on this (freed) link. */
    free_burst_cls (vl->sb_cls);
    GNUNET_assert (NULL == vl->sb_cls);
  }
  GNUNET_free (vl->burst_addr);
  GNUNET_break (NULL == vl->n);
  GNUNET_break (NULL == vl->dv);
  GNUNET_free (vl);
}

References VirtualLink::burst_addr, VirtualLink::cmc_head, VirtualLink::core_fc_stall_task, credit_client(), VirtualLink::csc_head, VirtualLink::csc_tail, VirtualLink::dv, VirtualLink::fc_retransmit_task, free_burst_cls(), 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_PEERSTORE_iteration_stop(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, VirtualLink::ic, links, VirtualLink::n, VirtualLink::pending_msg_head, VirtualLink::reassembly_heap, VirtualLink::reassembly_map, VirtualLink::reassembly_timeout_task, release_stalled_cmc(), VirtualLink::sb_cls, VirtualLink::target, VirtualLink::unconfirmed_timeout_task, VirtualLink::visibility_task, and CoreSentContext::vl.

Referenced by disconnect_and_free_virtual_link(), free_virtual_link_cb(), and unconfirmed_link_timeout().

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

vs	validation state to free

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

{
  if (NULL != vs->revalidation_task)
  {
    GNUNET_SCHEDULER_cancel (vs->revalidation_task);
    vs->revalidation_task = NULL;
  }
  /*memcpy (&hkey,
          &hc,
          sizeof (hkey));*/
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Remove key %s for address %s map size %u contains %u during freeing state\n",
              GNUNET_h2s (&vs->hc),
              vs->address,
              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
                                                      &vs->hc));
  GNUNET_CONTAINER_multihashmap_remove (revalidation_map, &vs->hc, vs);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (validation_map, &vs->pid, vs));
  GNUNET_CONTAINER_heap_remove_node (vs->hn);
  vs->hn = NULL;
  if (NULL != vs->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (vs->sc);
    vs->sc = NULL;
  }
  GNUNET_free (vs->address);
  GNUNET_free (vs);
}

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

pid	neighbour to look for

Returns

NULL if we do not have this peer as a neighbour

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

{
  return GNUNET_CONTAINER_multipeermap_get (neighbours, pid);
}

References GNUNET_CONTAINER_multipeermap_get(), neighbours, and Neighbour::pid.

Referenced by consider_sending_fc(), find_queue(), find_queue_by_ip(), forward_dv_learn(), handle_add_queue_message(), handle_communicator_backchannel(), handle_dv_box(), handle_dv_learn(), handle_incoming_msg(), learn_dv_path(), route_control_message_without_fc(), send_t_validation_response(), transmit_cummulative_ack_cb(), and try_to_bring_link_up().

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

pid	virtual link to look for

Returns

NULL if we do not have this peer as a virtual link

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

{
  return GNUNET_CONTAINER_multipeermap_get (links, pid);
}

References GNUNET_CONTAINER_multipeermap_get(), and links.

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_link_list_request(), handle_raw_message(), handle_validation_response(), send_t_validation_response(), start_address_validation(), suggest_retry_cb(), transmit_cummulative_ack_cb(), and validation_challenge_freq().

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

dvh	hop to free

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

{
  struct Neighbour *n = dvh->next_hop;
  struct DistanceVector *dv = dvh->dv;
  struct PendingAcknowledgement *pa;
 
  while (NULL != (pa = dvh->pa_head))
  {
    GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
    pa->dvh = NULL;
  }
  GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh);
  GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, dvh);
  GNUNET_free (dvh);
}

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

cls	a struct VirtualLink

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

{
  struct VirtualLink *vl = cls;
  struct DistanceVector *dv = vl->dv;
  struct Neighbour *n = vl->n;
  struct GNUNET_TIME_Absolute dvh_timeout;
  struct GNUNET_TIME_Absolute q_timeout;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Checking if link is down\n");
  vl->visibility_task = NULL;
  dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  if (NULL != dv)
  {
    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
         pos = pos->next_dv)
      dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout,
                                              pos->path_valid_until);
    if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
    {
      vl->dv->vl = NULL;
      vl->dv = NULL;
    }
  }
  q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  /* NOTE: @e n may be NULL here: #free_neighbour() clears vl->n and then
     schedules us when the link still has a DV route. */
  if (NULL != n)
  {
    struct GNUNET_TIME_Absolute liveness_deadline;
 
    /* A successful validation is good for #ADDRESS_VALIDATION_LIFETIME (four
       hours).  Do not take a communicator's word for that long: cap what the
       queues are worth by how recently this neighbour actually said anything
       to us.  Otherwise a communicator that stops working without sending a
       QUEUE_TEARDOWN keeps this link -- and CORE's idea of the connection --
       alive until the validation expires. */
    liveness_deadline = GNUNET_TIME_absolute_add (n->last_inbound,
                                                  NEIGHBOUR_LIVENESS_TIMEOUT);
    for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
      q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
    if (GNUNET_TIME_absolute_cmp (liveness_deadline, <, q_timeout))
    {
      if (0 ==
          GNUNET_TIME_absolute_get_remaining (liveness_deadline).rel_value_us)
      {
        /* Only reachable if a communicator failed to tear its queue down. */
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Neighbour %s was silent for %s while its communicator "
                    "kept claiming the queue works; treating link as down\n",
                    GNUNET_i2s (&vl->target),
                    GNUNET_STRINGS_relative_time_to_string (
                      NEIGHBOUR_LIVENESS_TIMEOUT,
                      GNUNET_YES));
        GNUNET_STATISTICS_update (GST_stats,
                                  "# links dropped (neighbour silent)",
                                  1,
                                  GNUNET_NO);
      }
      q_timeout = liveness_deadline;
    }
    if (0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
    {
      vl->n->vl = NULL;
      vl->n = NULL;
    }
  }
  if ((NULL == vl->n) && (NULL == vl->dv))
  {
    disconnect_and_free_virtual_link (vl);
    /* @e n (if any) outlives the link, and so do its queues: the liveness cap
       above drops a link whose addresses are still well inside
       #ADDRESS_VALIDATION_LIFETIME.  In that state nothing would ever ask for
       a fresh challenge -- @e revalidation_task does not fire until the four
       hour validity is nearly over, and the HELLO path reaches
       #start_address_validation() only to find an address that still counts
       as valid.  Since #handle_validation_response() is the only thing that
       can rebuild this link and tell CORE about the peer again, ask for that
       validation now, or CORE never hears about this peer again. */
    if (NULL != n)
      for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
        start_address_validation (&n->pid, q->address);
    return;
  }
  vl->visibility_task =
    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_max (q_timeout, dvh_timeout),
                             &check_link_down,
                             vl);
}

References check_link_down(), disconnect_and_free_virtual_link(), VirtualLink::dv, DistanceVector::dv_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_at(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_max(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, GST_stats, Neighbour::last_inbound, VirtualLink::n, NEIGHBOUR_LIVENESS_TIMEOUT, Neighbour::pid, q, Neighbour::queue_head, GNUNET_TIME_Relative::rel_value_us, start_address_validation(), 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

pid	peer the connection was for

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Informing CORE clients about disconnect from %s\n",
              GNUNET_i2s (pid));
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    struct GNUNET_MQ_Envelope *env;
    struct DisconnectInfoMessage *dim;
 
    if (CT_CORE != tc->type)
      continue;
    env = GNUNET_MQ_msg (dim, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
    dim->peer = *pid;
    GNUNET_MQ_send (tc->mq, env);
  }
}

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(), and tc.

Referenced by disconnect_and_free_virtual_link().

Here is the call graph for this function:

Here is the caller graph for this function:

try_to_bring_link_up()

static void try_to_bring_link_up ( const struct GNUNET_PeerIdentity *  pid )

static

Ask for everything that could give us a confirmed virtual link to pid: revalidate the addresses we already track, then those of the queues we still have, and failing both look for one in PEERSTORE.

Rate limited internally, so it is cheap to call often.

Parameters

pid	peer we want a link to

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

{
  struct Neighbour *n;
  struct IncomingRequest *ir;
 
  if (GNUNET_YES == in_shutdown)
    return;
  /* (1) Addresses we already track.  These outlive the queues, which is the
     point: once a link is down the queue that carried it is usually gone,
     so there is no address string left for #start_address_validation(). */
  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
                                                     pid,
                                                     &revalidate_now_cb,
                                                     NULL);
  /* (2) Queues we still have; may cover an address with no validation state
     yet.  After (1), because it may insert into #validation_map. */
  n = lookup_neighbour (pid);
  if (NULL != n)
    for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
      start_address_validation (pid, q->address);
  /* (3) Failing that, look for an address in PEERSTORE. */
  for (ir = ir_head; NULL != ir; ir = ir->next)
  {
    if (0 == GNUNET_memcmp (&ir->pid, pid))
      return;   /* we are already trying */
  }
  ir = GNUNET_new (struct IncomingRequest);
  ir->pid = *pid;
  GNUNET_CONTAINER_DLL_insert (ir_head, ir_tail, ir);
  /* Monitor only @a pid: with NULL every request sees every HELLO in
     PEERSTORE, so each of the up to #MAX_INCOMING_REQUEST requests started
     a connection attempt and an address validation for peers it was not
     created for. */
  ir->nc = GNUNET_PEERSTORE_monitor_start (GST_cfg,
                                           GNUNET_YES,
                                           "peerstore",
                                           &ir->pid,
                                           GNUNET_PEERSTORE_HELLO_KEY,
                                           &hello_for_incoming_error_cb,
                                           NULL,
                                           &hello_for_incoming_sync_cb,
                                           NULL,
                                           &handle_hello_for_incoming,
                                           ir);
  ir_total++;
  /* Bound attempts we do in parallel here, might otherwise get excessive.
     Drop the OLDEST request: #ir_head is the one we just inserted, so
     freeing that would immediately undo the work above. */
  while (ir_total > MAX_INCOMING_REQUEST)
    free_incoming_request (ir_tail);
}

References free_incoming_request(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_memcmp, GNUNET_new, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_YES, GST_cfg, handle_hello_for_incoming(), hello_for_incoming_error_cb(), hello_for_incoming_sync_cb(), in_shutdown, ir_head, ir_tail, ir_total, lookup_neighbour(), MAX_INCOMING_REQUEST, IncomingRequest::nc, IncomingRequest::next, IncomingRequest::pid, q, Neighbour::queue_head, revalidate_now_cb(), start_address_validation(), and validation_map.

Referenced by disconnect_and_free_virtual_link(), handle_flow_control(), send_t_validation_response(), and suggest_retry_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

disconnect_and_free_virtual_link()

static void disconnect_and_free_virtual_link ( struct VirtualLink *  vl )

static

Tell CORE clients the link to vl is gone, then release it.

Order matters. free_virtual_link() returns the send window credit for every message that never made it out, and that credit and the DISCONNECT travel the same client MQ in the order we queue them. A CORE client drops its ‘struct Neighbour’ – window and all – the instant it sees the DISCONNECT, so a SEND_OK queued behind it arrives for a peer the client no longer knows. That path is handle_send_ok()'s "we should never get a SEND_OK for a peer that we are not connected to" (transport_api_core.c), and it does not merely complain: it calls disconnect_and_schedule_reconnect(), which drops every neighbour the client has and forces a fresh key exchange with all of them. One link going down with a message still pending thus costs the peer all of its CORE sessions.

So pay out the credits first, while the client still has the neighbour to book them against. credit_client() is idempotent, so the calls free_virtual_link() makes afterwards are no-ops.

Parameters

vl	link that is going away

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

{
  struct GNUNET_PeerIdentity target = vl->target;
 
  for (struct PendingMessage *pm = vl->pending_msg_head;
       NULL != pm;
       pm = pm->next_vl)
    credit_client (pm);
  cores_send_disconnect_info (&vl->target);
  free_virtual_link (vl);
  /* Start getting it back now.  Only #handle_validation_response() can
     rebuild it, and a successful validation parks @e revalidation_task just
     short of #ADDRESS_VALIDATION_LIFETIME -- four hours away. */
  try_to_bring_link_up (&target);
}

References cores_send_disconnect_info(), credit_client(), free_virtual_link(), VirtualLink::pending_msg_head, VirtualLink::target, and try_to_bring_link_up().

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

dv	route to free

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

{
  struct DistanceVectorHop *dvh;
  struct VirtualLink *vl;
 
  while (NULL != (dvh = dv->dv_head))
    free_distance_vector_hop (dvh);
 
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (dv_routes, &dv->target, dv));
  if (NULL != (vl = dv->vl))
  {
    GNUNET_assert (dv == vl->dv);
    vl->dv = NULL;
    if (NULL == vl->n)
    {
      disconnect_and_free_virtual_link (vl);
    }
    else
    {
      /* @e visibility_task is NULL while #check_link_down() itself runs, and
         #GNUNET_SCHEDULER_cancel() dereferences its argument. */
      if (NULL != vl->visibility_task)
        GNUNET_SCHEDULER_cancel (vl->visibility_task);
      vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl);
    }
    dv->vl = NULL;
  }
 
  if (NULL != dv->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (dv->timeout_task);
    dv->timeout_task = NULL;
  }
  GNUNET_free (dv->km);
  GNUNET_free (dv);
}

References check_link_down(), disconnect_and_free_virtual_link(), VirtualLink::dv, DistanceVector::dv_head, dv_routes, free_distance_vector_hop(), 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

tc	monitor to inform
peer	peer the information is about
address	address the information is about
nt	network type associated with address
me	detailed information to transmit

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

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_MonitorData *md;
  size_t addr_len = strlen (address) + 1;
 
  env = GNUNET_MQ_msg_extra (md,
                             addr_len,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA);
  md->nt = htonl ((uint32_t) nt);
  md->peer = *peer;
  md->last_validation = GNUNET_TIME_absolute_hton (me->last_validation);
  md->valid_until = GNUNET_TIME_absolute_hton (me->valid_until);
  md->next_validation = GNUNET_TIME_absolute_hton (me->next_validation);
  md->rtt = GNUNET_TIME_relative_hton (me->rtt);
  md->cs = htonl ((uint32_t) me->cs);
  md->num_msg_pending = htonl (me->num_msg_pending);
  md->num_bytes_pending = htonl (me->num_bytes_pending);
  memcpy (&md[1], address, addr_len);
  GNUNET_MQ_send (tc->mq, env);
}

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

peer	peer the information is about
address	address the information is about
nt	network type associated with address
me	detailed information to transmit

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

{
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_MONITOR != tc->type)
      continue;
    if (tc->details.monitor.one_shot)
      continue;
    if ((GNUNET_NO == GNUNET_is_zero (&tc->details.monitor.peer)) &&
        (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer)))
      continue;
    notify_monitor (tc, peer, address, nt, me);
  }
}

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

cls	closure, NULL
client	identification of the client
mq	message queue for the client

Returns

our struct TransportClient

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

{
  struct TransportClient *tc;
 
  (void) cls;
  tc = GNUNET_new (struct TransportClient);
  tc->client = client;
  tc->mq = mq;
  GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p of type %u connected\n",
              tc,
              tc->type);
  return tc;
}

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

{
  struct TransportGlobalNattedAddress *tgna = value;
  (void) cls;
 
  GNUNET_free (tgna);
 
  return GNUNET_OK;
}

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

neighbour	neighbour entry to free
drop_link	flag to decide whether to drop its virtual link

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

{
  struct DistanceVectorHop *dvh;
  struct VirtualLink *vl;
 
  GNUNET_assert (NULL == neighbour->queue_head);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (neighbours,
                                                       &neighbour->pid,
                                                       neighbour));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Freeing neighbour\n");
  GNUNET_CONTAINER_multipeermap_iterate (neighbour->natted_addresses,
                                         &remove_global_addresses,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (neighbour->natted_addresses);
  while (NULL != (dvh = neighbour->dv_head))
  {
    struct DistanceVector *dv = dvh->dv;
 
    free_distance_vector_hop (dvh);
    if (NULL == dv->dv_head)
      free_dv_route (dv);
  }
  if (NULL != neighbour->get)
  {
    GNUNET_PEERSTORE_iteration_stop (neighbour->get);
    neighbour->get = NULL;
  }
  if (NULL != neighbour->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (neighbour->sc);
    neighbour->sc = NULL;
  }
  if (NULL != (vl = neighbour->vl))
  {
    GNUNET_assert (neighbour == vl->n);
    vl->n = NULL;
    if ((GNUNET_YES == drop_link) || (NULL == vl->dv))
    {
      disconnect_and_free_virtual_link (vl);
    }
    else
    {
      /* See #free_dv_route(): may be NULL under #check_link_down(). */
      if (NULL != vl->visibility_task)
        GNUNET_SCHEDULER_cancel (vl->visibility_task);
      vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl);
    }
    neighbour->vl = NULL;
  }
  GNUNET_free (neighbour);
}

References check_link_down(), disconnect_and_free_virtual_link(), VirtualLink::dv, DistanceVectorHop::dv, DistanceVector::dv_head, Neighbour::dv_head, free_distance_vector_hop(), free_dv_route(), 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::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

tc	client to inform (must be CORE client)
pid	peer the connection is for

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

{
  struct GNUNET_MQ_Envelope *env;
  struct ConnectInfoMessage *cim;
 
  GNUNET_assert (CT_CORE == tc->type);
  env = GNUNET_MQ_msg (cim, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
  cim->id = *pid;
  GNUNET_MQ_send (tc->mq, env);
}

References CT_CORE, env, GNUNET_assert, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT, GNUNET_MQ_msg, GNUNET_MQ_send(), ConnectInfoMessage::id, 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

pid	peer the queue was for

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Informing CORE clients about connection to %s\n",
              GNUNET_i2s (pid));
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_CORE != tc->type)
      continue;
    core_send_connect_info (tc, pid);
  }
}

References clients_head, core_send_connect_info(), CT_CORE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, 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

cls	the 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

cls	the struct Queue to process transmissions for

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

{
  struct Queue *queue = cls;
  struct Neighbour *n = queue->neighbour;
  struct PendingMessageScoreContext sc;
  struct PendingMessage *pm;
 
  queue->transmit_task = NULL;
  if ((NULL == n->vl) && (NULL == n->dv_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Virtual link `%s' is down, cannot have PM for queue `%s'\n",
                GNUNET_i2s (&n->pid),
                queue->address);
    queue->idle = GNUNET_YES;
    return;
  }
  memset (&sc, 0, sizeof(sc));
  /* @e n need not have a link of its own: it may serve only as the first
     hop of DV paths, and the traffic queued for those still has to go out. */
  if (NULL != n->vl)
    select_best_pending_from_link (&sc, queue, n->vl, NULL, 0);
  if (NULL == sc.best)
  {
    /* Also look at DVH that have the n as first hop! */
    for (struct DistanceVectorHop *dvh = n->dv_head; NULL != dvh;
         dvh = dvh->next_neighbour)
    {
      if (NULL == dvh->dv->vl)
        continue;   /* route not (yet) visible to CORE, no messages for it */
      select_best_pending_from_link (&sc,
                                     queue,
                                     dvh->dv->vl,
                                     dvh,
                                     sizeof(struct GNUNET_PeerIdentity)
                                     * (1 + dvh->distance)
                                     + sizeof(struct TransportDVBoxMessage)
                                     + sizeof(struct TransportDVBoxPayloadP));
    }
  }
  if (NULL == sc.best)
  {
    /* no message pending, nothing to do here! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No pending messages, queue `%s' to %s now idle\n",
                queue->address,
                GNUNET_i2s (&n->pid));
    if (GNUNET_YES == sc.to_early)
      schedule_transmit_on_queue (sc.to_early_retry_delay,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
    queue->idle = GNUNET_YES;
    return;
  }
  /* There is a message pending, we are certainly not idle */
  queue->idle = GNUNET_NO;
 
  /* Given selection in `sc`, do transmission */
  pm = sc.best;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Selected message <%" PRIu64 ">\n",
              pm->logging_uuid);
  if (NULL != sc.dvh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Is this %u a DV box?\n",
                pm->pmt);
    GNUNET_assert (PMT_DV_BOX != pm->pmt);
    if ((NULL != sc.best->bpm) && (sc.best->bpm->used_dvh != sc.dvh))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Discard old box, because we have a new DV path.\n");
      free_pending_message (sc.best->bpm);
      sc.best->bpm = NULL;
    }
 
    if (NULL == sc.best->bpm)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "encapsulate_for_dv 2\n");
      encapsulate_for_dv (sc.dvh->dv,
                          1,
                          &sc.dvh,
                          (const struct GNUNET_MessageHeader *) &sc.best[1],
                          &extract_box_cb,
                          &sc,
                          RMO_NONE,
                          GNUNET_NO);
      GNUNET_assert (NULL != sc.best->bpm);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "%lu %lu %lu %lu %u\n",
                  sizeof(struct GNUNET_PeerIdentity),
                  sizeof(struct TransportDVBoxMessage),
                  sizeof(struct TransportDVBoxPayloadP),
                  sizeof(struct TransportFragmentBoxMessage),
                  ((const struct GNUNET_MessageHeader *) &sc.best[1])->size);
      sc.best->bpm->used_dvh = sc.dvh;
    }
    pm = sc.best->bpm;
  }
  if (GNUNET_YES == sc.frag)
  {
    pm = fragment_message (queue, sc.dvh, pm);
    if (NULL == pm)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Fragmentation failed queue %s to %s for <%" PRIu64
                  ">, trying again\n",
                  queue->address,
                  GNUNET_i2s (&n->pid),
                  sc.best->logging_uuid);
      /* NOT with a zero delay: nothing about @a queue or about the message
         changed between here and the next pass, so "trying again" at once
         is a busy loop that reproduces the failure at scheduler speed. */
      schedule_transmit_on_queue (MIN_ACK_WAIT_DURATION,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
      return;
    }
  }
  else if (GNUNET_YES == sc.relb)
  {
    pm = reliability_box_message (queue, sc.dvh, pm);
    if (NULL == pm)
    {
      /* Reliability boxing failed, try next message... */
      GNUNET_log (
        GNUNET_ERROR_TYPE_DEBUG,
        "Reliability boxing failed queue %s to %s for <%" PRIu64
        ">, trying again\n",
        queue->address,
        GNUNET_i2s (&n->pid),
        sc.best->logging_uuid);
      /* Same reasoning as for the fragmentation failure above. */
      schedule_transmit_on_queue (MIN_ACK_WAIT_DURATION,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
      return;
    }
  }
 
  /* Pass 'pm' for transission to the communicator */
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Passing message <%" PRIu64
    "> to queue %s for peer %s (considered %u others)\n",
    pm->logging_uuid,
    queue->address,
    GNUNET_i2s (&n->pid),
    sc.consideration_counter);
 
  /* Flow control: increment amount of traffic sent; if we are routing
     via DV (and thus the ultimate target of the pending message is for
     a different virtual link than the one of the queue), then we need
     to use up not only the window of the direct link but also the
     flow control window for the DV link! */
  pm->vl->outbound_fc_window_size_used += pm->bytes_msg;
 
  if (pm->vl != queue->neighbour->vl)
  {
    /* If the virtual link of the queue differs, this better be distance
       vector routing! */
    GNUNET_assert (NULL != sc.dvh);
    /* If we do distance vector routing, we better not do this for a
       message that was itself DV-routed */
    GNUNET_assert (PMT_DV_BOX != sc.best->pmt);
    /* We use the size of the unboxed message here, to avoid counting
       the DV-Box header which is eaten up on the way by intermediaries.
       The next hop need not have a link of its own, in which case there is
       no window of it to charge. */
    if (NULL != queue->neighbour->vl)
      queue->neighbour->vl->outbound_fc_window_size_used += sc.best->bytes_msg;
  }
  else
  {
    GNUNET_assert (NULL == sc.dvh);
  }
 
  queue_send_msg (queue, pm, &pm[1], pm->bytes_msg);
 
  /* The message is with the communicator now, so return the CORE send
     window credit for it -- see #credit_client().
 
     It used to be returned here only for an unboxed message or a reliable
     communicator, and otherwise not until the *peer* acknowledged the
     message below.  That makes a window into a delivery confirmation: over
     an unreliable communicator every reliability-boxed or fragmented
     message holds one of the client's #SEND_WINDOW_SIZE slots for as long
     as its ACK takes, and a lost ACK holds it for the whole retransmission
     chain.  Four of those and CORE cannot send to that peer at all -- not
     payload, but also not its HEARTBEATs and not one message of its key
     exchange.  So the session times out for want of a heartbeat that is
     sitting in a queue, and the handshake that would rebuild it cannot go
     out either; CORE only recovers when a reconnect resets the window
     wholesale.  Acknowledgements still drive retransmission below, they
     just no longer gate the client. */
  credit_client (sc.best);
 
  /* Check if this transmission somehow conclusively finished handing 'pm'
     even without any explicit ACKs */
  if ((PMT_CORE == pm->pmt) ||
      (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc))
  {
    completed_pending_message (pm);
  }
  else
  {
    struct GNUNET_TIME_Relative wait_duration;
    unsigned int wait_multiplier;
 
    if (PMT_FRAGMENT_BOX == pm->pmt)
    {
      struct PendingMessage *root;
 
      root = pm->frag_parent;
      while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
        root = root->frag_parent;
 
      if ((0 == root->frag_off) || (0 == root->frag_count))
      {
        wait_multiplier = 4;
      }
      else
      {
        double wm = ceil ((double) root->bytes_msg
                          / ((double) root->frag_off
                             / (double) root->frag_count)) * 4.0;
 
        if ((! (wm >= 1.0)) || (wm > 1024.0))
          wm = 4.0;   /* NaN, infinity or absurd: fall back to the default */
        wait_multiplier = (unsigned int) wm;
      }
    }
    else
    {
      // No fragments, we use 4 RTT before retransmitting.
      wait_multiplier = 4;
    }
 
    // Depending on how much pending message the VirtualLink is queueing, we wait longer.
    // wait_multiplier = wait_multiplier * pm->vl->pending_msg_num;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Wait multiplier %u\n",
                wait_multiplier);
 
    /* Message not finished, waiting for acknowledgement.
       Update time by which we might retransmit 's' based on queue
       characteristics (i.e. RTT); it takes one RTT for the message to
       arrive and the ACK to come back in the best case; but the other
       side is allowed to delay ACKs by 2 RTTs, so we use 4 RTT before
       retransmitting.
 
       OPTIMIZE: Note that in the future this heuristic should likely
       be improved further (measure RTT stability, consider message
       urgency and size when delaying ACKs, etc.) */
 
    if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
        queue->pd.aged_rtt.rel_value_us)
      wait_duration = GNUNET_TIME_relative_max (queue->pd.aged_rtt,
                                                MIN_ACK_WAIT_DURATION);
    else
    {
      wait_duration = DEFAULT_ACK_WAIT_DURATION;
      wait_multiplier = 4;
    }
    {
      struct GNUNET_TIME_Absolute next = GNUNET_TIME_relative_to_absolute (
        GNUNET_TIME_relative_multiply (
          wait_duration, wait_multiplier));
      struct GNUNET_TIME_Relative plus = GNUNET_TIME_relative_multiply (
        wait_duration, wait_multiplier);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Waiting %s for ACK until %s\n",
                  GNUNET_STRINGS_relative_time_to_string (plus, GNUNET_NO),
                  GNUNET_STRINGS_absolute_time_to_string (next));
      update_pm_next_attempt (pm,
                              GNUNET_TIME_relative_to_absolute (
                                GNUNET_TIME_relative_multiply (wait_duration,
                                                               wait_multiplier))
                              );
    }
  }
  /* finally, re-schedule queue transmission task itself */
  schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                              queue,
                              GNUNET_SCHEDULER_PRIORITY_DEFAULT);
}

References PendingMessage::bytes_msg, completed_pending_message(), credit_client(), 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_max(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO, GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_YES, PendingMessage::logging_uuid, MIN_ACK_WAIT_DURATION, VirtualLink::outbound_fc_window_size_used, Neighbour::pid, 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(), Neighbour::vl, and PendingMessage::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 there is another queue to the same neighbour, over a different communicator, that has a higher priority and is ready for sending.

Parameters

queue	queue we are considering transmission on
queue_head	first queue to the neighbour of queue

Returns

GNUNET_YES if a better queue exists and should be preferred

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

{
  for (struct Queue *s = queue_head; NULL != s;
       s = s->next_neighbour)
  {
    if (s == queue)
      continue;
    if (s->tc->details.communicator.address_prefix !=
        queue->tc->details.communicator.address_prefix)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "queue address %s qid %u compare with queue: address %s qid %u\n",
                  queue->address,
                  queue->qid,
                  s->address,
                  s->qid);
      if ((s->priority > queue->priority) && (0 < s->q_capacity) &&
          (QUEUE_LENGTH_LIMIT > s->queue_length) )
        return GNUNET_YES;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Lower prio\n");
    }
  }
  return GNUNET_NO;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, Queue::next_neighbour, 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:

arm_free_queue_entry_task()

static void arm_free_queue_entry_task ( struct TransportClient *  tc )

static

Make sure free_timedout_queue_entry() will run for tc, so that `struct QueueEntry's the communicator never acknowledged are reclaimed.

Parameters

tc	communicator whose queue entries need sweeping

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

{
  if (NULL != tc->details.communicator.free_queue_entry_task)
    return;
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    if (NULL == queue->queue_head)
      continue;
    tc->details.communicator.free_queue_entry_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                    &free_timedout_queue_entry,
                                    tc);
    return;
  }
}

References free_timedout_queue_entry(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_SECONDS, queue(), and tc.

Referenced by free_timedout_queue_entry(), queue_send_msg(), and 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

queue	the queue to do scheduling for
p	task priority to use, if queue is scheduled

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

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
  if (queue->validated_until.abs_value_us < now.abs_value_us)
    return;
  if (check_for_queue_with_higher_prio (queue,
                                        queue->neighbour->queue_head))
    return;
 
  if (queue->tc->details.communicator.total_queue_length >=
      COMMUNICATOR_TOTAL_QUEUE_LIMIT)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission on queue %s (QID %u) throttled due to communicator queue limit\n",
                queue->address,
                queue->qid);
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Transmission throttled due to communicator queue limit",
      1,
      GNUNET_NO);
    queue->idle = GNUNET_NO;
    /* @e total_queue_length is shared by every peer this communicator serves,
       so at the limit we can send to none of them, and the only things that
       lower it again are an ACK from the communicator, #free_queue() and
       #free_timedout_queue_entry().  If we got here because a peer stopped
       acknowledging, no ACK is coming; and we just declined to arm
       @e transmit_task, so #queue_send_msg() -- the *only* place that arms
       the sweeper -- will not run either.  That leaves nothing at all to
       recover the count, and the communicator stays mute towards every peer
       until some unrelated queue happens to go down.  Keep the sweeper
       going. */
    arm_free_queue_entry_task (queue->tc);
    return;
  }
  if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission on queue %s (QID %u) throttled due to communicator queue length limit\n",
                queue->address,
                queue->qid);
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to queue queue limit",
                              1,
                              GNUNET_NO);
    queue->idle = GNUNET_NO;
    /* Same reasoning as above, for the per-queue limit. */
    arm_free_queue_entry_task (queue->tc);
    return;
  }
  if (0 == queue->q_capacity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission on queue %s (QID %u) throttled due to communicator message  has capacity %"
                PRIu64 ".\n",
                queue->address,
                queue->qid,
                queue->q_capacity);
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to message queue capacity",
                              1,
                              GNUNET_NO);
    queue->idle = GNUNET_NO;
    return;
  }
  /* queue might indeed be ready, schedule it */
  if (NULL != queue->transmit_task)
    GNUNET_SCHEDULER_cancel (queue->transmit_task);
  queue->transmit_task =
    GNUNET_SCHEDULER_add_delayed_with_priority (delay, p, &transmit_on_queue,
                                                queue);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Considering transmission on queue `%s' QID %llu to %s\n",
              queue->address,
              (unsigned long long) queue->qid,
              GNUNET_i2s (&queue->neighbour->pid));
}

References GNUNET_TIME_Absolute::abs_value_us, arm_free_queue_entry_task(), 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_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:

start_address_validation()

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

static

Start address validation.

Parameters

pid	peer the address is for
address	an address to reach pid (presumably)

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

{
  struct GNUNET_TIME_Absolute now;
  struct ValidationState *vs;
  struct CheckKnownAddressContext ckac = { .address = address, .vs = NULL };
 
  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
                                                     pid,
                                                     &check_known_address,
                                                     &ckac);
  now = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  if (NULL != (vs = ckac.vs))
  {
    const struct VirtualLink *vl = lookup_virtual_link (pid);
 
    /* Speed up retrying the validation if 'vs' is not currently valid, or if
     * we have no confirmed virtual link to @a pid.  In the latter case the
     * address may still be well inside its validity window -- but the link is
     * down, and #handle_validation_response() is the only thing that can
     * rebuild it and tell CORE about the peer again.  Without this we would
     * wait for @e revalidation_task, which does not fire until
     * #ADDRESS_VALIDATION_LIFETIME is nearly over. */
    if ((vs->validated_until.abs_value_us < vs->next_challenge.abs_value_us) ||
        (NULL == vl) ||
        (GNUNET_NO == vl->confirmed))
    {
      /* reduce backoff as we got a fresh advertisement */
      speed_up_challenge (vs);
      /* A successful validation parks @e first_challenge_use just before
         @e validated_until, so that the *next* challenge is not used before
         the current validation is about to expire.  #validation_start_cb()
         refuses to run while that time is still in the future, so pulling
         @e next_challenge in without this would only make it reschedule
         itself four hours out.  The challenge has not been used yet, so
         moving the start of its window to now stays truthful -- it is what
         the fresh-@a vs path below does as well. */
      if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
        vs->first_challenge_use = now;
      update_next_challenge_time (vs,
                                  GNUNET_TIME_relative_to_absolute (
                                    vs->challenge_backoff));
    }
    return;
  }
  vs = GNUNET_new (struct ValidationState);
  vs->pid = *pid;
  vs->valid_until =
    GNUNET_TIME_relative_to_absolute (ADDRESS_VALIDATION_LIFETIME);
  vs->first_challenge_use = now;
  vs->validation_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
  GNUNET_CRYPTO_random_block (&vs->challenge,
                              sizeof(vs->challenge));
  vs->address = GNUNET_strdup (address);
  {
    /* The peer identity MUST be part of @e hc: two peers behind the same NAT
       advertise the very same address string (`PROTO-IP:0'), and with an
       address-only key the second one's #revalidation_map entry would be
       rejected as a duplicate of the first one's. */
    struct GNUNET_HashContext *hsh;
 
    hsh = GNUNET_CRYPTO_hash_context_start ();
    GNUNET_CRYPTO_hash_context_read (hsh, vs->address, strlen (vs->address));
    GNUNET_CRYPTO_hash_context_read (hsh, &vs->pid, sizeof(vs->pid));
    GNUNET_CRYPTO_hash_context_finish (hsh, &vs->hc);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting address validation `%s' of peer %s using challenge %s\n",
              address,
              GNUNET_i2s (pid),
              GNUNET_sh2s (&vs->challenge.value));
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_put (
                   validation_map,
                   &vs->pid,
                   vs,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  update_next_challenge_time (vs, now);
}

References GNUNET_TIME_Absolute::abs_value_us, address, CheckKnownAddressContext::address, ADDRESS_VALIDATION_LIFETIME, check_known_address(), VirtualLink::confirmed, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), GNUNET_CRYPTO_random_block(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_sh2s(), GNUNET_strdup, GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GST_cfg, lookup_virtual_link(), ValidationState::pid, speed_up_challenge(), update_next_challenge_time(), ValidationState::valid_until, ValidationState::validated_until, validation_map, and CheckKnownAddressContext::vs.

Referenced by check_link_down(), handle_add_queue_message(), handle_request_hello_validation(), hello_for_client_cb(), hello_for_incoming_cb(), and try_to_bring_link_up().

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

queue

the queue to free

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

{
  struct Neighbour *neighbour = queue->neighbour;
  struct TransportClient *tc = queue->tc;
  struct MonitorEvent me = { .cs = GNUNET_TRANSPORT_CS_DOWN,
                             .rtt = GNUNET_TIME_UNIT_FOREVER_REL };
  struct QueueEntry *qe;
  int maxxed;
  struct PendingAcknowledgement *pa;
  struct VirtualLink *vl;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Cleaning up queue %u\n", queue->qid);
  if (NULL != queue->mo)
  {
    GNUNET_PEERSTORE_monitor_stop (queue->mo);
    queue->mo = NULL;
  }
  if (NULL != queue->transmit_task)
  {
    GNUNET_SCHEDULER_cancel (queue->transmit_task);
    queue->transmit_task = NULL;
  }
  while (NULL != (pa = queue->pa_head))
  {
    GNUNET_CONTAINER_MDLL_remove (queue, queue->pa_head, queue->pa_tail, pa);
    pa->queue = NULL;
  }
 
  GNUNET_CONTAINER_MDLL_remove (neighbour,
                                neighbour->queue_head,
                                neighbour->queue_tail,
                                queue);
  GNUNET_CONTAINER_MDLL_remove (client,
                                tc->details.communicator.queue_head,
                                tc->details.communicator.queue_tail,
                                queue);
  maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT <=
            tc->details.communicator.total_queue_length);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Cleaning up queue with length %u\n",
              queue->queue_length);
  while (NULL != (qe = queue->queue_head))
  {
    GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe);
    queue->queue_length--;
    tc->details.communicator.total_queue_length--;
    if (NULL != qe->pm)
    {
      GNUNET_assert (qe == qe->pm->qe);
      qe->pm->qe = NULL;
    }
    GNUNET_free (qe);
  }
  GNUNET_assert (0 == queue->queue_length);
  if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT >
                   tc->details.communicator.total_queue_length))
  {
    /* Communicator dropped below threshold, resume all _other_ queues */
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Transmission throttled due to communicator queue limit",
      -1,
      GNUNET_NO);
    for (struct Queue *s = tc->details.communicator.queue_head; NULL != s;
         s = s->next_client)
      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                  s,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  }
  notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
  GNUNET_free (queue);
 
  vl = lookup_virtual_link (&neighbour->pid);
  if ((NULL != vl) && (neighbour == vl->n))
  {
    /* See #free_dv_route(): may be NULL under #check_link_down(), which is
       also what clears it -- so the call below needs no re-arm here. */
    if (NULL != vl->visibility_task)
      GNUNET_SCHEDULER_cancel (vl->visibility_task);
    vl->visibility_task = NULL;
    check_link_down (vl);
  }
  if (NULL == neighbour->queue_head)
  {
    free_neighbour (neighbour, GNUNET_NO);
  }
}

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(), handle_del_queue_message(), and handle_send_message_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

cancel_address_store()

static void cancel_address_store ( struct AddressListEntry *  ale )

static

Abort the asynchronous sign-and-store chain (if any) that is currently running for ale and release its context.

Without this, PILS and PEERSTORE callbacks keep a pointer to ale and run after it was freed.

Parameters

ale	address list entry to cancel operations for
ale	address list entry to cancel operations for

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

{
  struct PilsAddressSignContext *pc = ale->pc;
 
  if (NULL == pc)
    return;
  ale->pc = NULL;
  /* Each stage of the chain passes @a pc as its closure, so every handle
     that could still deliver one has to go before @a pc is released. */
  if (NULL != ale->sc)
  {
    GNUNET_PEERSTORE_store_cancel (ale->sc);
    ale->sc = NULL;
  }
  if (NULL != ale->shc)
  {
    GNUNET_PEERSTORE_hello_add_cancel (ale->shc);
    ale->shc = NULL;
  }
  if (NULL != pc->req)
  {
    if (NULL != pc->req->op)
      GNUNET_PILS_cancel (pc->req->op);
    GNUNET_CONTAINER_DLL_remove (pils_requests_head,
                                 pils_requests_tail,
                                 pc->req);
    GNUNET_free (pc->req);
    pc->req = NULL;
  }
  GNUNET_free (pc);
}

References PilsAddressSignContext::ale, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_PEERSTORE_hello_add_cancel(), GNUNET_PEERSTORE_store_cancel(), GNUNET_PILS_cancel(), pc, AddressListEntry::pc, pils_requests_head, pils_requests_tail, AddressListEntry::sc, and AddressListEntry::shc.

Referenced by free_address_list_entry(), and pils_sign_address().

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

ale	address list entry to free

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

{
  struct TransportClient *tc = ale->tc;
 
  GNUNET_CONTAINER_DLL_remove (tc->details.communicator.addr_head,
                               tc->details.communicator.addr_tail,
                               ale);
  /* Cancels @e sc, @e shc and the pending PILS signature request, all of
     which would otherwise run their callbacks on this freed entry. */
  cancel_address_store (ale);
  if (NULL != ale->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (ale->sc);
    ale->sc = NULL;
  }
  if (NULL != ale->shc)
  {
    GNUNET_PEERSTORE_hello_add_cancel (ale->shc);
    ale->shc = NULL;
  }
  if (NULL != ale->st)
  {
    GNUNET_SCHEDULER_cancel (ale->st);
    ale->st = NULL;
  }
  if (NULL != ale->signed_address)
    GNUNET_free (ale->signed_address);
  GNUNET_free (ale);
}

References cancel_address_store(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERSTORE_hello_add_cancel(), GNUNET_PEERSTORE_store_cancel(), GNUNET_SCHEDULER_cancel(), AddressListEntry::sc, AddressListEntry::shc, 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

cls	a struct TransportClient that no longer makes the request
pid	the peer's identity
value	a struct PeerRequest

Returns

GNUNET_YES (always)

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

{
  struct TransportClient *tc = cls;
  struct PeerRequest *pr = value;
 
  if (NULL != pr->retry_task)
  {
    GNUNET_SCHEDULER_cancel (pr->retry_task);
    pr->retry_task = NULL;
  }
  if (NULL != pr->nc)
    GNUNET_PEERSTORE_monitor_stop (pr->nc);
  pr->nc = NULL;
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests,
                                          pid,
                                          pr));
  GNUNET_free (pr);
 
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_PEERSTORE_monitor_stop(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, PeerRequest::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

cls	closure, unused

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

{
  static int shutdown_done;
  struct LearnLaunchEntry *lle;
  struct PilsRequest *pr;
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "shutdown logic\n");
  if (GNUNET_YES == shutdown_done)
    return;   /* reachable both from #shutdown_task() and #client_disconnect_cb() */
  shutdown_done = GNUNET_YES;
  if (NULL != client_grace_task)
  {
    GNUNET_SCHEDULER_cancel (client_grace_task);
    client_grace_task = NULL;
  }
  if (NULL != nh)
  {
    GNUNET_NAT_unregister (nh);
    nh = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &free_neighbour_cb, NULL);
  /* Freeing a neighbour takes its virtual link with it, so whatever is
     left here is ownerless: a link we created from an inbound FLOW_CONTROL
     message that never got confirmed, kept alive only by its @e
     unconfirmed_timeout_task.  #GNUNET_SCHEDULER_shutdown() does not run
     that task, so leaving the link in place left the task armed against a
     map we destroy further down -- it fired afterwards and
     #free_virtual_link() called GNUNET_CONTAINER_multipeermap_remove() on
     NULL.  Drop them here, while every structure they touch is still
     alive. */
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &free_virtual_link_cb,
                                         NULL);
  if (NULL != validation_task)
  {
    GNUNET_SCHEDULER_cancel (validation_task);
    validation_task = NULL;
  }
  if (NULL != dvlearn_task)
  {
    GNUNET_SCHEDULER_cancel (dvlearn_task);
    dvlearn_task = NULL;
  }
  if (NULL != burst_task)
  {
    GNUNET_SCHEDULER_cancel (burst_task);
    burst_task = NULL;
  }
  if (NULL != burst_timeout_task)
  {
    GNUNET_SCHEDULER_cancel (burst_timeout_task);
    burst_timeout_task = NULL;
  }
  burst_running = GNUNET_NO;
  GNUNET_CONTAINER_multishortmap_destroy (dvlearn_map);
  dvlearn_map = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (dv_routes, &free_dv_routes_cb, NULL);
  GNUNET_CONTAINER_multipeermap_destroy (dv_routes);
  dv_routes = NULL;
  if (NULL != GST_stats)
  {
    GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
    GST_stats = NULL;
  }
  if (NULL != GST_my_hello)
  {
    GNUNET_HELLO_builder_free (GST_my_hello);
    GST_my_hello = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (ack_cummulators,
                                         &free_ack_cummulator_cb,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (ack_cummulators);
  ack_cummulators = NULL;
  GNUNET_CONTAINER_multiuuidmap_iterate (pending_acks,
                                         &free_pending_ack_cb,
                                         NULL);
  GNUNET_CONTAINER_multiuuidmap_destroy (pending_acks);
  pending_acks = NULL;
  GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (neighbours));
  GNUNET_CONTAINER_multipeermap_destroy (neighbours);
  neighbours = NULL;
  GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (links));
  GNUNET_CONTAINER_multipeermap_destroy (links);
  links = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (backtalkers,
                                         &free_backtalker_cb,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (backtalkers);
  backtalkers = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (validation_map,
                                         &free_validation_state_cb,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (validation_map);
  validation_map = NULL;
  GNUNET_CONTAINER_heap_destroy (validation_heap);
  validation_heap = NULL;
  GNUNET_CONTAINER_multihashmap_destroy (revalidation_map);
  revalidation_map = NULL;
  while (NULL != ir_head)
    free_incoming_request (ir_head);
  GNUNET_assert (0 == ir_total);
  while (NULL != (lle = lle_head))
  {
    GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
    GNUNET_free (lle);
  }
  while (NULL != (pr = pils_requests_head))
  {
    GNUNET_CONTAINER_DLL_remove (pils_requests_head,
                                 pils_requests_tail,
                                 pr);
    if (NULL != pr->op)
      GNUNET_PILS_cancel (pr->op);
    GNUNET_free (pr);
  }
  if (NULL != pils_feed_task)
  {
    GNUNET_SCHEDULER_cancel (pils_feed_task);
    pils_feed_task = NULL;
  }
  if (NULL != pils)
  {
    GNUNET_PILS_disconnect (pils);
    pils = NULL;
  }
  if (NULL != peerstore)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Disconnecting from PEERSTORE service\n");
    GNUNET_PEERSTORE_disconnect (peerstore);
    peerstore = NULL;
  }
  GNUNET_SCHEDULER_shutdown ();
}

References ack_cummulators, backtalkers, burst_running, burst_task, burst_timeout_task, client_grace_task, 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(), free_virtual_link_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_PILS_cancel(), GNUNET_PILS_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_destroy(), GNUNET_YES, GST_my_hello, GST_stats, ir_head, ir_total, links, lle_head, lle_tail, neighbours, nh, PilsRequest::op, peerstore, pending_acks, pils, pils_feed_task, pils_requests_head, pils_requests_tail, revalidation_map, validation_heap, validation_map, and validation_task.

Here is the call graph for this function:

detach_cmcs_from_link()

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

static

Detach the `struct CommunicatorMessageContext's parked on value from the client in cls.

Parameters

cls	the struct TransportClient that is going away
pid	unused
value	a struct VirtualLink

Returns

GNUNET_OK (continue to iterate)

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

{
  const struct TransportClient *tc = cls;
  struct VirtualLink *vl = value;
 
  (void) pid;
  for (struct CommunicatorMessageContext *cmc = vl->cmc_head;
       NULL != cmc;
       cmc = cmc->next)
    if (tc == cmc->tc)
      cmc->tc = NULL;
  return GNUNET_OK;
}

References VirtualLink::cmc_head, GNUNET_OK, tc, and value.

Referenced by detach_cmcs_from_client().

Here is the caller graph for this function:

detach_cmc_from_backtalker()

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

static

Detach the ‘struct CommunicatorMessageContext’ parked on value from the client in cls.

Parameters

cls	the struct TransportClient that is going away
pid	unused
value	a struct Backtalker

Returns

GNUNET_OK (continue to iterate)

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

{
  const struct TransportClient *tc = cls;
  struct Backtalker *b = value;
 
  (void) pid;
  if ((NULL != b->cmc) && (tc == b->cmc->tc))
    b->cmc->tc = NULL;
  return GNUNET_OK;
}

References Backtalker::cmc, GNUNET_OK, Backtalker::pid, tc, CommunicatorMessageContext::tc, and value.

Referenced by detach_cmcs_from_client().

Here is the caller graph for this function:

detach_cmcs_from_client()

static void detach_cmcs_from_client ( const struct TransportClient *  tc )

static

A communicator client is going away.

Detach every ‘struct CommunicatorMessageContext’ that still points at it.

A cmc does not end with the handler that created it: it is parked on cmc_head of a ‘struct VirtualLink’ while CORE's receive window for that link is exhausted (see finish_handling_raw_message()), on a ‘struct Backtalker’ across a PEERSTORE round trip (see decaps_dv_box_cont()), or in ring_buffer while the link is still coming up (see handle_raw_message()). Each of those is released later by a path that runs send_cmc_ack() and resume_cmc_client() on tc – which client_disconnect_cb() is about to free. Whether that later path runs during this disconnect (free_virtual_link() releases the parked cmcs of a link it tears down) or long after it (a RECV_OK, the CORE stall timeout, a PEERSTORE reply), the client is no longer ours to touch.

Parameters

tc	client that is being disconnected

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

{
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &detach_cmcs_from_link,
                                         (void *) tc);
  GNUNET_CONTAINER_multipeermap_iterate (backtalkers,
                                         &detach_cmc_from_backtalker,
                                         (void *) tc);
  for (unsigned int i = 0; i < RING_BUFFER_SIZE; i++)
    if ((NULL != ring_buffer[i]) &&
        (tc == ring_buffer[i]->cmc->tc))
      ring_buffer[i]->cmc->tc = NULL;
}

References backtalkers, RingBufferEntry::cmc, Backtalker::cmc, detach_cmc_from_backtalker(), detach_cmcs_from_link(), GNUNET_CONTAINER_multipeermap_iterate(), links, ring_buffer, RING_BUFFER_SIZE, tc, and CommunicatorMessageContext::tc.

Referenced by client_disconnect_cb().

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

cls	closure, NULL
client	identification of the client
app_ctx	our struct TransportClient

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

{
  struct TransportClient *tc = app_ctx;
 
  (void) cls;
  (void) client;
  GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
  switch (tc->type)
  {
  case CT_NONE:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Unknown Client %p disconnected, cleaning up.\n",
                tc);
    break;
 
  case CT_CORE: {
      struct PendingMessage *pm;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "CORE Client %p disconnected, cleaning up.\n",
                  tc);
 
 
      while (NULL != (pm = tc->details.core.pending_msg_head))
      {
        GNUNET_CONTAINER_MDLL_remove (client,
                                      tc->details.core.pending_msg_head,
                                      tc->details.core.pending_msg_tail,
                                      pm);
        pm->client = NULL;
      }
    }
    break;
 
  case CT_MONITOR:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "MONITOR Client %p disconnected, cleaning up.\n",
                tc);
 
    break;
 
  case CT_COMMUNICATOR: {
      struct Queue *q;
      struct AddressListEntry *ale;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "COMMUNICATOR Client %p disconnected, cleaning up.\n",
                  tc);
 
      /* MUST come first: freeing the queues below can tear a virtual link
         down, and #free_virtual_link() releases the cmcs parked on it. */
      detach_cmcs_from_client (tc);
      if (NULL != tc->details.communicator.free_queue_entry_task)
        GNUNET_SCHEDULER_cancel (
          tc->details.communicator.free_queue_entry_task);
      while (NULL != (q = tc->details.communicator.queue_head))
        free_queue (q);
      while (NULL != (ale = tc->details.communicator.addr_head))
        free_address_list_entry (ale);
      GNUNET_free (tc->details.communicator.address_prefix);
    }
    break;
 
  case CT_APPLICATION:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "APPLICATION Client %p disconnected, cleaning up.\n",
                tc);
 
    GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests,
                                           &stop_peer_request,
                                           tc);
    GNUNET_CONTAINER_multipeermap_destroy (tc->details.application.requests);
    break;
  }
  GNUNET_free (tc);
  if ((GNUNET_YES == in_shutdown) && (NULL == clients_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Our last client disconnected\n");
    do_shutdown (cls);
  }
}

References PendingMessage::client, TransportClient::client, clients_head, clients_tail, CT_APPLICATION, CT_COMMUNICATOR, CT_CORE, CT_MONITOR, CT_NONE, detach_cmcs_from_client(), 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_INFO, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_YES, in_shutdown, 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

cls	the new struct TransportClient
pid	a connected peer
value	the struct Neighbour with more information

Returns

GNUNET_OK (continue to iterate)

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

{
  struct TransportClient *tc = cls;
  struct VirtualLink *vl = value;
 
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
    return GNUNET_OK;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Telling new CORE client about existing connection to %s\n",
              GNUNET_i2s (pid));
  core_send_connect_info (tc, pid);
  return GNUNET_OK;
}

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

Referenced by handle_client_start().

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

{
  struct VirtualLink *vl = value;
  struct CommunicatorMessageContext *cmc;
 
  /* resume communicators */
  while (NULL != (cmc = vl->cmc_tail))
    release_stalled_cmc (vl, cmc);
  if (NULL != vl->core_fc_stall_task)
  {
    GNUNET_SCHEDULER_cancel (vl->core_fc_stall_task);
    vl->core_fc_stall_task = NULL;
  }
  /* A CORE client that just attached has nothing outstanding, so give it a
     full window.  The RECV_OKs that would have returned the credit spent by
     its predecessor died with that client, and #handle_client_recv_ok() is
     the only thing that ever raises this counter -- so without the reset
     every message on this link takes the "CORE ran out of window" path from
     here on, and only #core_fc_stalled() (after CORE_FC_STALL_TIMEOUT, and
     once per round) ever lets any through. */
  vl->core_recv_window = RECV_WINDOW_SIZE;
  return GNUNET_OK;
}

References VirtualLink::cmc_tail, VirtualLink::core_fc_stall_task, VirtualLink::core_recv_window, GNUNET_OK, GNUNET_SCHEDULER_cancel(), RECV_WINDOW_SIZE, release_stalled_cmc(), 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

cls	the client
start	the start message that was sent

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

{
  // const struct GNUNET_PeerIdentity *my_identity;
  struct TransportClient *tc = cls;
  // uint32_t options;
  //
  // my_identity = GNUNET_PILS_get_identity (pils);
  // GNUNET_assert (my_identity);
  //
  // FIXME ignore the check of the peer ids for now.
  //       (also deprecate the old way of obtaining our own peer ID)
  // options = ntohl (start->options);
  // if ((0 != (1 & options)) &&
  //    (0 != GNUNET_memcmp (&start->self, my_identity)))
  // {
  //  /* client thinks this is a different peer, reject */
  //  GNUNET_break (0);
  //  GNUNET_SERVICE_client_drop (tc->client);
  //  return;
  // }
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  tc->type = CT_CORE;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New CORE client with PID %s registered\n",
              GNUNET_i2s (&start->self));
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &notify_client_connect_info,
                                         tc);
  GNUNET_CONTAINER_multipeermap_iterate (links,
                                         &resume_communicators,
                                         NULL);
  GNUNET_SERVICE_client_continue (tc->client);
}

References CT_CORE, CT_NONE, GNUNET_break, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), links, notify_client_connect_info(), 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

cls	the client
obm	the send message that was sent

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

{
  struct TransportClient *tc = cls;
  uint16_t size;
  const struct GNUNET_MessageHeader *obmm;
 
  if (CT_CORE != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
  if (size < sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
  if (size != ntohs (obmm->size))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

pm	handle to the original pending message

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

{
  struct TransportClient *tc = pm->client;
  struct VirtualLink *vl = pm->vl;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "client send response\n");
  if (NULL != tc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Confirming transmission of <%" PRIu64 "> to %s\n",
                pm->logging_uuid,
                GNUNET_i2s (&vl->target));
    credit_client (pm);
  }
  free_pending_message (pm);
}

References PendingMessage::client, credit_client(), free_pending_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, PendingMessage::logging_uuid, VirtualLink::target, tc, and PendingMessage::vl.

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

	dv	data structure to pick paths from
	options	constraints to satisfy
[out]	hops_array	set to the result
	hops_array_length	length of the hops_array

Returns

number of entries set in hops_array

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

{
  uint64_t choices[hops_array_length];
  uint64_t num_dv;
  unsigned int dv_count;
 
  /* Pick random vectors, but weighted by distance, giving more weight
     to shorter vectors */
  num_dv = 0;
  dv_count = 0;
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
         .rel_value_us == 0))
      continue;   /* pos unconfirmed and confirmed required */
    /* A hop at (or past) the limit has weight zero -- past it, unsigned
       arithmetic makes the weight huge.  Either way it can never be picked
       below, so it must not be counted: the sampling loop draws
       @a hops_array_length distinct values out of @e num_dv, and counting a
       hop that contributes nothing to @e num_dv can leave it with fewer
       values than draws, which never terminates.  #learn_dv_path() caps
       @e distance well below the limit today, so this is defence in depth. */
    if (pos->distance >= MAX_DV_HOPS_ALLOWED)
      continue;
    num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
    dv_count++;
  }
  if (0 == dv_count)
    return 0;
  if (dv_count <= hops_array_length)
  {
    dv_count = 0;
    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
         pos = pos->next_dv)
      hops_array[dv_count++] = pos;
    return dv_count;
  }
  for (unsigned int i = 0; i < hops_array_length; i++)
  {
    int ok = GNUNET_NO;
    unsigned int tries = 0;
 
    while (GNUNET_NO == ok)
    {
      choices[i] =
        GNUNET_CRYPTO_random_u64 (num_dv);
      ok = GNUNET_YES;
      for (unsigned int j = 0; j < i; j++)
        if (choices[i] == choices[j])
        {
          ok = GNUNET_NO;
          break;
        }
      /* Give up rather than spin: with weight >= 2 per hop the expected
         number of draws per pick is below four, so this many failures is a
         set we cannot sample distinctly.  Returning fewer paths is a routing
         nuisance, hanging here is a deaf service; and a duplicated choice
         would at worst repeat a path, so stopping is safe. */
      if (MAX_DV_PICK_TRIES < ++tries)
        break;
    }
    if (GNUNET_NO == ok)
    {
      hops_array_length = i;
      break;
    }
  }
  dv_count = 0;
  num_dv = 0;
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    uint64_t delta;
 
    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
         .rel_value_us == 0))
      continue;   /* pos unconfirmed and confirmed required */
    if (pos->distance >= MAX_DV_HOPS_ALLOWED)
      continue;   /* zero weight: not counted in @e num_dv above either */
    delta = MAX_DV_HOPS_ALLOWED - pos->distance;
    for (unsigned int i = 0; i < hops_array_length; i++)
      if ((num_dv <= choices[i]) && (num_dv + delta > choices[i]))
        hops_array[dv_count++] = pos;
    num_dv += delta;
  }
  return dv_count;
}

References delta, VirtualLink::dv, DistanceVector::dv_head, GNUNET_CRYPTO_random_u64(), GNUNET_NO, GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, MAX_DV_HOPS_ALLOWED, MAX_DV_PICK_TRIES, 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

cls	the client
cam	the send message that was sent

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

{
  struct TransportClient *tc = cls;
  uint16_t size;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  tc->type = CT_COMMUNICATOR;
  size = ntohs (cam->header.size) - sizeof(*cam);
  if (0 == size)
    return GNUNET_OK; /* receive-only communicator */
  GNUNET_MQ_check_zero_termination (cam);
  return GNUNET_OK;
}

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.

send_cmc_ack()

static void send_cmc_ack ( struct CommunicatorMessageContext *  cmc )

static

Release the CORE flow control credit for cmc by acknowledging the message to the communicator that delivered it.

Idempotent: the ACK carries a flow control id the communicator retires on receipt, so a second one would match nothing, and GNUNET_TRANSPORT_communicator_receive()'s caller reacts to that by dropping its whole transport connection.

Parameters

cmc	context for which we are done handling the message

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

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TRANSPORT_IncomingMessageAck *ack;
 
  if (GNUNET_YES == cmc->ack_sent)
    return;
  cmc->ack_sent = GNUNET_YES;
  if (NULL == cmc->tc)
    return;   /* communicator is gone, see #detach_cmcs_from_client() */
  if (0 == ntohl (cmc->im.fc_on))
    return;   /* communicator did not ask for flow control */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Acknowledge message with flow control id %" PRIu64 "\n",
              cmc->im.fc_id);
  env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK);
  ack->reserved = htonl (0);
  ack->fc_id = cmc->im.fc_id;
  ack->sender = cmc->im.neighbour_sender;
  GNUNET_MQ_send (cmc->tc->mq, env);
}

References CommunicatorMessageContext::ack_sent, env, GNUNET_TRANSPORT_IncomingMessage::fc_id, GNUNET_TRANSPORT_IncomingMessageAck::fc_id, GNUNET_TRANSPORT_IncomingMessage::fc_on, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK, GNUNET_MQ_msg, GNUNET_MQ_send(), 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_with_continue().

Here is the call graph for this function:

Here is the caller graph for this function:

resume_cmc_client()

static void resume_cmc_client ( struct CommunicatorMessageContext *  cmc )

static

Let the communicator that delivered cmc give us its next message.

This is per client, and one client serves every peer reachable over that communicator, so it must not be held back for anything that concerns a single virtual link. Idempotent, as the service API expects exactly one continue per message received.

Parameters

cmc	context whose client to resume

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

{
  if (GNUNET_YES == cmc->client_resumed)
    return;
  cmc->client_resumed = GNUNET_YES;
  if (NULL == cmc->tc)
    return;   /* communicator is gone, see #detach_cmcs_from_client() */
  GNUNET_SERVICE_client_continue (cmc->tc->client);
}

References TransportClient::client, CommunicatorMessageContext::client_resumed, GNUNET_SERVICE_client_continue(), GNUNET_YES, and CommunicatorMessageContext::tc.

Referenced by finish_cmc_handling_with_continue(), and finish_handling_raw_message().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_cmc_handling()

static void finish_cmc_handling ( struct CommunicatorMessageContext *  cmc )

static

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

{
  finish_cmc_handling_with_continue (cmc, GNUNET_YES);
}

References finish_cmc_handling_with_continue(), and GNUNET_YES.

Referenced by backtalker_monotime_cb(), decaps_dv_box_cont(), 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(), handle_validation_response(), and send_t_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

cls	the client
rom	the message that was sent

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

{
  struct TransportClient *tc = cls;
  struct VirtualLink *vl;
  uint32_t delta;
  struct CommunicatorMessageContext *cmc;
 
  if (CT_CORE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  vl = lookup_virtual_link (&rom->peer);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# RECV_OK dropped: virtual link unknown",
                              1,
                              GNUNET_NO);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  delta = ntohl (rom->increase_window_delta);
  vl->core_recv_window += delta;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "CORE ack receiving message, increased CORE recv window to %d\n",
              vl->core_recv_window);
  GNUNET_SERVICE_client_continue (tc->client);
  if (vl->core_recv_window <= 0)
    return;
  /* release the flow control credit we withheld from the communicators */
  while (NULL != (cmc = vl->cmc_tail))
    release_stalled_cmc (vl, cmc);
  if (NULL != vl->core_fc_stall_task)
  {
    GNUNET_SCHEDULER_cancel (vl->core_fc_stall_task);
    vl->core_fc_stall_task = NULL;
  }
}

References VirtualLink::cmc_tail, VirtualLink::confirmed, VirtualLink::core_fc_stall_task, VirtualLink::core_recv_window, CT_CORE, delta, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GST_stats, RecvOkMessage::increase_window_delta, lookup_virtual_link(), RecvOkMessage::peer, release_stalled_cmc(), 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

cls	the client
cam	the send message that was sent

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

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct TransportClient *tc = cls;
  uint16_t size;
 
  size = ntohs (cam->header.size) - sizeof(*cam);
  if (0 == size)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Receive-only communicator connected\n");
    /* Receive-only communicator: it has no address prefix, but we still
       MUST resume the client or we will never read from it again.  Use an
       empty prefix so that the various strcmp()s do not see NULL. */
    tc->details.communicator.address_prefix = GNUNET_strdup ("");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  tc->details.communicator.address_prefix =
    GNUNET_strdup ((const char *) &cam[1]);
  tc->details.communicator.cc = ntohl (cam->cc);
  tc->details.communicator.can_burst = ntohl (cam->can_burst);
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL != my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Communicator for peer %s with prefix '%s' connected %s\n",
                GNUNET_i2s (my_identity),
                tc->details.communicator.address_prefix,
                tc->details.communicator.can_burst ? "can burst" :
                "can not burst");
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Communicator for local peer with prefix '%s' connected %s\n",
                tc->details.communicator.address_prefix,
                tc->details.communicator.can_burst ? "can burst" :
                "can not burst");
  }
  GNUNET_SERVICE_client_continue (tc->client);
}

References GNUNET_TRANSPORT_CommunicatorAvailableMessage::can_burst, GNUNET_TRANSPORT_CommunicatorAvailableMessage::cc, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_PILS_get_identity(), GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_TRANSPORT_CommunicatorAvailableMessage::header, my_identity, pils, 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

cls	the client
cb	the send message that was sent

Returns

GNUNET_OK if message is well-formed

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

{
  const struct GNUNET_MessageHeader *inbox;
  const char *is;
  uint16_t msize;
  uint16_t isize;
 
  (void) cls;
  msize = ntohs (cb->header.size) - sizeof(*cb);
  inbox = (const struct GNUNET_MessageHeader *) &cb[1];
  /* MUST bound the buffer before dereferencing @a inbox. */
  if (msize <= sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  isize = ntohs (inbox->size);
  if (isize >= msize)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  is = (const char *) inbox;
  is += isize;
  msize -= isize;
  GNUNET_assert (0 < msize);
  if ('\0' != is[msize - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

sign_ephemeral()

static enum GNUNET_GenericReturnValue sign_ephemeral ( struct DistanceVector *  dv )

static

Sign the ephemeral key in dv, and mark it current.

MUST be synchronous. encapsulate_for_dv() copies sender_sig into the box it is about to encrypt on the very next line, so a signature that only arrives once PILS answers is a signature the receiver never sees. Worse, ephemeral_key and monotime are updated here and go out immediately: every box sent between the call and the answer carries the new ephemeral under the previous signature, which the receiver cannot verify, and it drops all of them.

Parameters

[in,out]

dv

distance vector to update the ephemeral for

Returns

GNUNET_OK if sender_sig now covers ephemeral_key

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

{
  struct EphemeralConfirmationPS ec;
 
  dv->monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  dv->ephemeral_validity =
    GNUNET_TIME_absolute_add (dv->monotime, EPHEMERAL_VALIDITY);
  ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
  ec.target = dv->target;
  ec.ephemeral_key = dv->ephemeral_key;
  ec.sender_monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
  ec.purpose.size = htonl (sizeof(ec));
  return sign_by_my_identity (&ec.purpose, &dv->sender_sig);
}

References EphemeralConfirmationPS::ephemeral_key, DistanceVector::ephemeral_key, EPHEMERAL_VALIDITY, DistanceVector::ephemeral_validity, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GST_cfg, DistanceVector::monotime, GNUNET_CRYPTO_SignaturePurpose::purpose, EphemeralConfirmationPS::purpose, EphemeralConfirmationPS::sender_monotonic_time, DistanceVector::sender_sig, sign_by_my_identity(), GNUNET_CRYPTO_SignaturePurpose::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 13457 of file gnunet-service-transport.c.

{
  struct PendingMessage *pm;
 
  GNUNET_CONTAINER_DLL_remove (qe->queue->queue_head,
                               qe->queue->queue_tail,
                               qe);
  qe->queue->queue_length--;
  tc->details.communicator.total_queue_length--;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ACK on queue %s (QID %u) to peer %s (new length: %u/%u)\n",
              qe->queue->address,
              qe->queue->qid,
              GNUNET_i2s (&qe->queue->neighbour->pid),
              qe->queue->queue_length,
              tc->details.communicator.total_queue_length);
 
  /* if applicable, resume transmissions that waited on ACK */
  if (COMMUNICATOR_TOTAL_QUEUE_LIMIT - 1 ==
      tc->details.communicator.total_queue_length)
  {
    /* Communicator dropped below threshold, resume all queues
       incident with this client! */
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Transmission throttled due to communicator queue limit",
      -1,
      GNUNET_NO);
    for (struct Queue *queue = tc->details.communicator.queue_head;
         NULL != queue;
         queue = queue->next_client)
    {
      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                  queue,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
    }
  }
  else if (QUEUE_LENGTH_LIMIT - 1 == qe->queue->queue_length)
  {
    /* queue dropped below threshold; only resume this one queue */
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to queue queue limit",
                              -1,
                              GNUNET_NO);
    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                qe->queue,
                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  }
  else if (1 == qe->queue->q_capacity)
  {
    // TODO I guess this will never happen, because the communicator triggers this by updating its queue length itself.
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmission rescheduled due to communicator message queue with qid %u has capacity %"
                PRIu64 ".\n",
                qe->queue->qid,
                qe->queue->q_capacity);
    /* message queue has capacity; only resume this one queue */
    /* queue dropped below threshold; only resume this one queue */
    GNUNET_STATISTICS_update (GST_stats,
                              "# Transmission throttled due to message queue capacity",
                              -1,
                              GNUNET_NO);
    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                qe->queue,
                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  }
 
  if (NULL != (pm = qe->pm))
  {
    struct VirtualLink *vl;
 
    // GNUNET_assert (qe == pm->qe);
    pm->qe = NULL;
    /* If waiting for this communicator may have blocked transmission
       of pm on other queues for this neighbour, force schedule
       transmit on queue for queues of the neighbour */
    if (NULL == pm->frag_parent)
    {
      vl = pm->vl;
      if ((NULL != vl) &&
          (NULL != vl->pending_msg_head) &&
          (vl->pending_msg_head == pm))
        check_vl_transmission (vl);
    }
  }
  GNUNET_free (qe);
}

References check_vl_transmission(), COMMUNICATOR_TOTAL_QUEUE_LIMIT, PendingMessage::frag_parent, 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, qe, PendingMessage::qe, queue(), QUEUE_LENGTH_LIMIT, schedule_transmit_on_queue(), tc, and PendingMessage::vl.

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

{
  struct TransportClient *tc = cls;
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "freeing timedout queue entries\n");
 
  tc->details.communicator.free_queue_entry_task = NULL;
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    struct QueueEntry *qep = queue->queue_head;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "checking QID %u for timedout queue entries\n",
                queue->qid);
    while (NULL != qep)
    {
      struct QueueEntry *pos = qep;
      struct GNUNET_TIME_Relative diff = GNUNET_TIME_absolute_get_difference (
        pos->creation_timestamp, now);
      qep = qep->next;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "diff to now %s \n",
                  GNUNET_TIME_relative2s (diff, GNUNET_NO));
      if (GNUNET_TIME_relative_cmp (QUEUE_ENTRY_TIMEOUT, <, diff))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Freeing timed out QueueEntry with MID %" PRIu64
                    " and QID %u\n",
                    pos->mid,
                    queue->qid);
        GNUNET_STATISTICS_update (GST_stats,
                                  "# QueueEntries timed out",
                                  1,
                                  GNUNET_NO);
        free_queue_entry (pos, tc);
      }
    }
  }
  /* Entries younger than #QUEUE_ENTRY_TIMEOUT are still to be reclaimed, and
     this task used to be a one-shot armed only by #queue_send_msg().  So the
     sweep that was supposed to bound how long an unacknowledged entry holds
     its slot only ever ran while *new* messages were being queued -- exactly
     not the case once the throttles in #schedule_transmit_on_queue() have
     stopped transmission.  Keep going as long as anything is outstanding. */
  arm_free_queue_entry_task (tc);
}

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

Referenced by arm_free_queue_entry_task().

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

queue	the queue to use for transmission
pm	pending message to update once transmission is done, may be NULL!
payload	the payload to send (encapsulated in a GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG).
payload_size	number of bytes in payload

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

{
  struct Neighbour *n = queue->neighbour;
  struct GNUNET_TRANSPORT_SendMessageTo *smt;
  struct GNUNET_MQ_Envelope *env;
  struct PendingAcknowledgement *pa;
 
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Queueing %u bytes of payload for transmission <%" PRIu64
    "> on queue %llu to %s\n",
    (unsigned int) payload_size,
    (NULL == pm) ? 0 : pm->logging_uuid,
    (unsigned long long) queue->qid,
    GNUNET_i2s (&queue->neighbour->pid));
  env = GNUNET_MQ_msg_extra (smt,
                             payload_size,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG);
  smt->qid = htonl (queue->qid);
  smt->mid = GNUNET_htonll (queue->mid_gen);
  smt->receiver = n->pid;
  memcpy (&smt[1], payload, payload_size);
  {
    /* Pass the env to the communicator of queue for transmission. */
    struct QueueEntry *qe;
 
    qe = GNUNET_new (struct QueueEntry);
    qe->creation_timestamp = GNUNET_TIME_absolute_get ();
    qe->mid = queue->mid_gen;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Create QueueEntry with MID %" PRIu64
                " and QID %u and prefix %s\n",
                qe->mid,
                queue->qid,
                queue->tc->details.communicator.address_prefix);
    queue->mid_gen++;
    qe->queue = queue;
    if (NULL != pm)
    {
      qe->pm = pm;
      // TODO Why do we have a retransmission. When we know, make decision if we still want this.
      // GNUNET_assert (NULL == pm->qe);
      if (NULL != pm->qe)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Retransmitting message <%" PRIu64
                    "> remove pm from qe with MID: %llu \n",
                    pm->logging_uuid,
                    (unsigned long long) pm->qe->mid);
        pm->qe->pm = NULL;
      }
      pm->qe = qe;
    }
    GNUNET_assert (CT_COMMUNICATOR == queue->tc->type);
    if (0 == queue->q_capacity)
    {
      // Messages without FC or fragments can get here.
      if (NULL != pm)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Message %" PRIu64
                    " (pm type %u) was not send because queue has no capacity.\n",
                    pm->logging_uuid,
                    pm->pmt);
        pm->qe = NULL;
      }
      GNUNET_free (env);
      GNUNET_free (qe);
      return;
    }
    GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe);
    queue->queue_length++;
    queue->tc->details.communicator.total_queue_length++;
    if (GNUNET_NO == queue->unlimited_length)
      queue->q_capacity--;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Queue %s with qid %u has capacity %" PRIu64 "\n",
                queue->address,
                queue->qid,
                queue->q_capacity);
    if (COMMUNICATOR_TOTAL_QUEUE_LIMIT ==
        queue->tc->details.communicator.total_queue_length)
      queue->idle = GNUNET_NO;
    if (QUEUE_LENGTH_LIMIT == queue->queue_length)
      queue->idle = GNUNET_NO;
    if (0 == queue->q_capacity)
      queue->idle = GNUNET_NO;
 
    if (GNUNET_NO == queue->idle)
      arm_free_queue_entry_task (queue->tc);
    if (NULL != pm)
    {
      /* NOTE: @e next_pa was never the link of this list -- nothing ever
         assigned it, so it was NULL on every entry.  The MDLL that
         #prepare_pending_acknowledgement() inserts into is keyed `pm', and
         thus threaded through @e next_pm.  Walking @e next_pa dereferenced
         NULL the moment the head was not the entry we wanted. */
      for (pa = pm->pa_head; NULL != pa; pa = pa->next_pm)
        if (pm == pa->pm)
        {
          pa->num_send++;
          break;
        }
    }
    // GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending message MID %" PRIu64
                " of type %u (%u) and size %lu with MQ %p queue %s (QID %u) pending %"
                PRIu64 "\n",
                GNUNET_ntohll (smt->mid),
                ntohs (((const struct GNUNET_MessageHeader *) payload)->type),
                ntohs (smt->header.size),
                (unsigned long) payload_size,
                queue->tc->mq,
                queue->address,
                queue->qid,
                (NULL == pm) ? 0 : pm->logging_uuid);
    GNUNET_MQ_send (queue->tc->mq, env);
  }
}

References arm_free_queue_entry_task(), COMMUNICATOR_TOTAL_QUEUE_LIMIT, CT_COMMUNICATOR, env, 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_TIME_absolute_get(), GNUNET_TRANSPORT_SendMessageTo::header, PendingMessage::logging_uuid, QueueEntry::mid, GNUNET_TRANSPORT_SendMessageTo::mid, PendingAcknowledgement::next_pm, PendingAcknowledgement::num_send, PendingMessage::pa_head, payload, Neighbour::pid, PendingAcknowledgement::pm, QueueEntry::pm, PendingMessage::pmt, qe, PendingMessage::qe, GNUNET_TRANSPORT_SendMessageTo::qid, queue(), QUEUE_LENGTH_LIMIT, GNUNET_TRANSPORT_SendMessageTo::receiver, GNUNET_MessageHeader::size, and type.

Referenced by route_via_neighbour(), transmit_dv_init(), 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

n	neighbour to send to
hdr	message to send as payload
options	whether 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 5791 of file gnunet-service-transport.c.

{
  struct GNUNET_TIME_Absolute now;
  unsigned int candidates;
  unsigned int sel1;
  unsigned int sel2;
  struct GNUNET_TIME_Relative rtt;
 
  /* Pick one or two 'random' queues from n (under constraints of options) */
  now = GNUNET_TIME_absolute_get ();
  /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to
     weight in the future; weight could be assigned by observed
     bandwidth (note: not sure if we should do this for this type
     of control traffic though). */
  candidates = 0;
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
        (pos->validated_until.abs_value_us > now.abs_value_us))
      candidates++;
  }
  if (0 == candidates)
  {
    /* This can happen rarely if the last confirmed queue timed
       out just as we were beginning to process this message. */
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Could not route message of type %u to %s: no valid queue\n",
                ntohs (hdr->type),
                GNUNET_i2s (&n->pid));
    GNUNET_STATISTICS_update (GST_stats,
                              "# route selection failed (all no valid queue)",
                              1,
                              GNUNET_NO);
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
 
  rtt = GNUNET_TIME_UNIT_FOREVER_REL;
  sel1 = GNUNET_CRYPTO_random_u32 (candidates);
  if (0 == (options & RMO_REDUNDANT))
    sel2 = candidates; /* picks none! */
  else
    sel2 = GNUNET_CRYPTO_random_u32 (candidates);
  candidates = 0;
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
        (pos->validated_until.abs_value_us > now.abs_value_us))
    {
      if ((sel1 == candidates) || (sel2 == candidates))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Routing message of type %u to %s using %s (#%u)\n",
                    ntohs (hdr->type),
                    GNUNET_i2s (&n->pid),
                    pos->address,
                    (sel1 == candidates) ? 1 : 2);
        rtt = GNUNET_TIME_relative_min (rtt, pos->pd.aged_rtt);
        queue_send_msg (pos, NULL, hdr, ntohs (hdr->size));
      }
      candidates++;
    }
  }
  return rtt;
}

References GNUNET_TIME_Absolute::abs_value_us, 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(), route_control_message_without_fc(), send_dv_to_neighbour(), send_t_validation_response(), and transmit_cummulative_ack_cb().

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

target	neighbour to ultimately send to
num_dvhs	length of the dvhs array
dvhs	array of hops to send the message to
hdr	message to send as payload
use	function to call with the encapsulated message
use_cls	closure for use
options	whether path must be confirmed or not, to be passed to use
without_fc	shall this TransportDVBoxMessage be forwarded without flow control.

Returns

expected RTT for transmission, GNUNET_TIME_UNIT_FOREVER_REL if sending failed

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

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct TransportDVBoxMessage box_hdr;
  struct TransportDVBoxPayloadP *payload_hdr;
  uint16_t body_len_hbo = ntohs (hdr->size);
  unsigned char pt[sizeof(struct TransportDVBoxPayloadP) + body_len_hbo]
  GNUNET_ALIGN;
  unsigned char ct[sizeof(struct TransportDVBoxPayloadP) + body_len_hbo]
  GNUNET_ALIGN;
  struct GNUNET_TIME_Relative rtt;
  struct GNUNET_CRYPTO_AeadSecretKey km;
 
  payload_hdr = (struct TransportDVBoxPayloadP*) pt;
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  /* Encrypt payload */
  memset (&box_hdr, 0, sizeof (box_hdr));
  box_hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
  box_hdr.total_hops = htons (0);
  box_hdr.without_fc = htonl (without_fc);
  // update_ephemeral (dv);
  if ((0 ==
       GNUNET_TIME_absolute_get_remaining (dv->ephemeral_validity).rel_value_us)
      || (NULL == dv->km))
  {
    GNUNET_CRYPTO_eddsa_kem_encaps (&dv->target.public_key,
                                    &dv->ephemeral_key,
                                    (struct GNUNET_ShortHashCode*) &km);
    GNUNET_free (dv->km);   /* do not leak the previous key material */
    dv->km = GNUNET_new (struct GNUNET_ShortHashCode);
    GNUNET_memcpy (dv->km, &km, sizeof(struct GNUNET_ShortHashCode));
    if (GNUNET_OK != sign_ephemeral (dv))
    {
      /* Without a matching signature the box is undecryptable noise to the
         receiver; do not spend the bandwidth.  Expire the ephemeral so the
         next attempt re-derives and re-signs rather than reusing it. */
      dv->ephemeral_validity = GNUNET_TIME_UNIT_ZERO_ABS;
      return GNUNET_TIME_UNIT_FOREVER_REL;
    }
  }
  else
  {
    /* The ephemeral key is still valid, so reuse the cached key material.
       Without this @a km stayed UNINITIALISED stack memory and the
       receiver could not decrypt the box. */
    GNUNET_memcpy (&km, dv->km, sizeof(struct GNUNET_ShortHashCode));
  }
  box_hdr.ephemeral_key = dv->ephemeral_key;
  payload_hdr->sender_sig = dv->sender_sig;
  memcpy (&payload_hdr[1], hdr, body_len_hbo);
  GNUNET_CRYPTO_random_block (&box_hdr.iv,
                              sizeof(box_hdr.iv));
  payload_hdr->sender = *my_identity;
  payload_hdr->monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
  GNUNET_CRYPTO_aead_encrypt (sizeof pt,
                              pt,
                              0,
                              NULL,
                              &km,
                              &box_hdr.iv,
                              ct,
                              &box_hdr.mac);
  rtt = GNUNET_TIME_UNIT_FOREVER_REL;
  /* For each selected path, take the pre-computed header and body
     and add the path in the middle of the message; then send it. */
  for (unsigned int i = 0; i < num_dvhs; i++)
  {
    struct DistanceVectorHop *dvh = dvhs[i];
    unsigned int num_hops = dvh->distance + 1;
    char buf[sizeof(struct TransportDVBoxMessage)
             + sizeof(struct GNUNET_PeerIdentity) * num_hops
             + sizeof(struct TransportDVBoxPayloadP)
             + body_len_hbo] GNUNET_ALIGN;
    struct GNUNET_PeerIdentity *dhops;
 
    box_hdr.header.size = htons (sizeof(buf));
    box_hdr.orig_size = htons (sizeof(buf));
    box_hdr.num_hops = htons (num_hops);
    memcpy (buf, &box_hdr, sizeof(box_hdr));
    dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)];
    memcpy (dhops,
            dvh->path,
            dvh->distance * sizeof(struct GNUNET_PeerIdentity));
    dhops[dvh->distance] = dv->target;
    if (GNUNET_EXTRA_LOGGING > 0)
    {
      char *path;
 
      path = GNUNET_strdup (GNUNET_i2s (my_identity));
      for (unsigned int j = 0; j < num_hops; j++)
      {
        char *tmp;
 
        GNUNET_asprintf (&tmp, "%s-%s", path, GNUNET_i2s (&dhops[j]));
        GNUNET_free (path);
        path = tmp;
      }
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Routing message of type %u to %s using DV (#%u/%u) via %s\n",
                  ntohs (hdr->type),
                  GNUNET_i2s (&dv->target),
                  i + 1,
                  num_dvhs,
                  path);
      GNUNET_free (path);
    }
    rtt = GNUNET_TIME_relative_min (rtt, dvh->pd.aged_rtt);
    memcpy (&dhops[num_hops], ct, sizeof(ct));
    use (use_cls,
         dvh->next_hop,
         (const struct GNUNET_MessageHeader *) buf,
         options);
  }
  return rtt;
}

References PerformanceData::aged_rtt, DistanceVectorHop::distance, TransportDVBoxMessage::ephemeral_key, GNUNET_ALIGN, GNUNET_asprintf(), GNUNET_assert, GNUNET_CRYPTO_aead_encrypt(), GNUNET_CRYPTO_eddsa_kem_encaps(), 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_OK, GNUNET_PILS_get_identity(), GNUNET_strdup, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_min(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO_ABS, TransportDVBoxMessage::header, TransportDVBoxMessage::iv, TransportDVBoxMessage::mac, TransportDVBoxPayloadP::monotonic_time, my_identity, DistanceVectorHop::next_hop, TransportDVBoxMessage::num_hops, options, TransportDVBoxMessage::orig_size, DistanceVectorHop::path, DistanceVectorHop::pd, pils, 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

cls	unused
next_hop	where to send next
hdr	header of the message to send
options	message options for queue selection

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

{
  (void) cls;
  (void) route_via_neighbour (next_hop, hdr, RMO_UNCONFIRMED_ALLOWED);
}

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

target	peer to receive hdr
hdr	header of the message to route and GNUNET_free()
options	which transmission channels are allowed

Returns

expected RTT for transmission, GNUNET_TIME_UNIT_FOREVER_REL if sending failed

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

{
  // struct VirtualLink *vl;
  struct Neighbour *n;
  struct DistanceVector *dv;
  struct GNUNET_TIME_Relative rtt1;
  struct GNUNET_TIME_Relative rtt2;
  const struct GNUNET_PeerIdentity *target = &vl->target;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Trying to route message of type %u to %s without fc\n",
              ntohs (hdr->type),
              GNUNET_i2s (target));
 
  // TODO Do this elsewhere. vl should be given as parameter to method.
  // vl = lookup_virtual_link (target);
  /* An unconfirmed link is allowed here: it has no @e n and no @e dv of its
     own, so the "confirmed required" branch below resolves the route from
     #neighbours / #dv_routes.  Refusing to route at all is what deadlocks a
     pair of peers, see #consider_sending_fc(). */
  GNUNET_assert (NULL != vl);
  n = vl->n;
  dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL;
  /* An unconfirmed link has neither @e n nor @e dv of its own, so resolve
     the route from #neighbours / #dv_routes.  This used to be done only
     while #RMO_UNCONFIRMED_ALLOWED was *not* set -- exactly backwards: with
     the flag set (the caller that needs it most) we would find no route at
     all and drop the message.  Whether an unvalidated queue or an
     unvalidated path may then be used is still decided by @a options, in
     #route_via_neighbour() and #pick_random_dv_hops(). */
  if (NULL == n)
    n = lookup_neighbour (target);
  if ((NULL == dv) && (0 != (options & RMO_DV_ALLOWED)))
    dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, target);
  if ((NULL == n) && (NULL == dv))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Cannot route message of type %u to %s: no route\n",
                ntohs (hdr->type),
                GNUNET_i2s (target));
    GNUNET_STATISTICS_update (GST_stats,
                              "# Messages dropped in routing: no acceptable method",
                              1,
                              GNUNET_NO);
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Routing message of type %u to %s with options %X\n",
              ntohs (hdr->type),
              GNUNET_i2s (target),
              (unsigned int) options);
  /* If both dv and n are possible and we must choose:
     flip a coin for the choice between the two; for now 50/50 */
  if ((NULL != n) && (NULL != dv) && (0 == (options & RMO_REDUNDANT)))
  {
    if (0 == GNUNET_CRYPTO_random_u32 (2))
      n = NULL;
    else
      dv = NULL;
  }
  if ((NULL != n) && (NULL != dv))
    options &= ~RMO_REDUNDANT; /* We will do one DV and one direct, that's
                                  enough for redundancy, so clear the flag. */
  rtt1 = GNUNET_TIME_UNIT_FOREVER_REL;
  rtt2 = GNUNET_TIME_UNIT_FOREVER_REL;
  if (NULL != n)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Try to route message of type %u to %s without fc via neighbour\n",
                ntohs (hdr->type),
                GNUNET_i2s (target));
    rtt1 = route_via_neighbour (n, hdr, options);
  }
  if (NULL != dv)
  {
    struct DistanceVectorHop *hops[2];
    unsigned int res;
 
    res = pick_random_dv_hops (dv,
                               options,
                               hops,
                               (0 == (options & RMO_REDUNDANT)) ? 1 : 2);
    if (0 == res)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Failed to route message, could not determine DV path\n");
      return rtt1;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "encapsulate_for_dv 1\n");
    rtt2 = encapsulate_for_dv (dv,
                               res,
                               hops,
                               hdr,
                               &send_dv_to_neighbour,
                               NULL,
                               options & (~RMO_REDUNDANT),
                               GNUNET_YES);
  }
  return GNUNET_TIME_relative_min (rtt1, rtt2);
}

References DistanceVectorHop::dv, dv_routes, encapsulate_for_dv(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), 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, route_via_neighbour(), send_dv_to_neighbour(), and GNUNET_MessageHeader::type.

Referenced by consider_sending_fc(), forward_dv_learn(), handle_communicator_backchannel(), send_t_validation_response(), 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

cls	a struct VirtualLink to work with

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

{
  struct VirtualLink *vl = cls;
  struct GNUNET_TIME_Absolute monotime;
  struct TransportFlowControlMessage *fc;
  struct GNUNET_TIME_Relative duration;
  struct GNUNET_TIME_Relative rtt;
  struct GNUNET_TIME_Relative rtt_average;
  struct Neighbour *n = vl->n;
  size_t addresses_size;
 
  /* Most of our callers are not the retransmit task but inbound events:
     handle_flow_control() ends in check_vl_transmission(), which calls us
     once per flow-control-stalled message, and the peer's answer to what we
     send here arrives as another handle_flow_control().  On a link whose
     head message does not fit the window that is a ping-pong with nothing
     to damp it -- the backoff and the MIN_FC_RETRANSMIT_DELAY floor at the
     bottom of this function only ever governed @e fc_retransmit_task, which
     these callers bypass.  If the chain is armed and we just sent one, let
     the task do it. */
  if ((NULL != vl->fc_retransmit_task) &&
      (GNUNET_TIME_absolute_get_duration (vl->last_fc_transmission).rel_value_us
       < MIN_FC_RETRANSMIT_DELAY.rel_value_us))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Not sending FC to %s: one went out less than %s ago\n",
                GNUNET_i2s (&vl->target),
                GNUNET_STRINGS_relative_time_to_string (
                  MIN_FC_RETRANSMIT_DELAY,
                  GNUNET_YES));
    return;
  }
  if ((GNUNET_YES != vl->confirmed) &&
      (NULL == lookup_neighbour (&vl->target)) &&
      (NULL == GNUNET_CONTAINER_multipeermap_get (dv_routes, &vl->target)))
  {
    /* Unconfirmed AND no way to reach the peer at all -- nothing to send on.
       An unconfirmed link that *does* have a route must still answer,
       see below.
 
       Do NOT just return: #task_consider_sending_fc() cleared
       @e fc_retransmit_task before calling us, and the only other place that
       arms it is #handle_flow_control() -- which only does so when it is
       already non-NULL.  Leaving without re-arming therefore ends the
       keepalive chain for this link permanently, and #check_link_down()
       tears it down #NEIGHBOUR_LIVENESS_TIMEOUT later. */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Not sending FC to %s: link unconfirmed and no route\n",
                GNUNET_i2s (&vl->target));
    if (NULL == vl->fc_retransmit_task)
      vl->fc_retransmit_task =
        GNUNET_SCHEDULER_add_delayed (FC_KEEPALIVE_INTERVAL,
                                      &task_consider_sending_fc,
                                      vl);
    return;
  }
  addresses_size = 0;
  if (NULL != n && 0 < n->number_of_addresses)
  {
    addresses_size =
      n->number_of_addresses * sizeof (struct TransportGlobalNattedAddress) + n
      ->size_of_global_addresses;
    if (addresses_size >
        UINT16_MAX - sizeof (struct TransportFlowControlMessage))
    {
      /* htons() below would silently truncate `header.size', leaving a
         message whose declared length does not match its contents. */
      GNUNET_break (0);
      addresses_size = 0;
    }
  }
  if (0 != addresses_size)
  {
    char *tgnas = GNUNET_malloc (addresses_size);
    struct AddGlobalAddressesContext ctx;
    ctx.off = 0;
    ctx.size = addresses_size;
    ctx.tgnas = tgnas;
 
    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage)
                        + addresses_size);
    fc->header.size = htons (sizeof(struct TransportFlowControlMessage)
                             + addresses_size);
    fc->size_of_addresses = htonl ((uint32_t) n->size_of_global_addresses);
    fc->number_of_addresses = htonl (n->number_of_addresses);
    GNUNET_CONTAINER_multipeermap_iterate (n->natted_addresses,
                                           &add_global_addresses,
                                           &ctx);
    GNUNET_memcpy (&fc[1], tgnas, addresses_size);
    GNUNET_free (tgnas);
  }
  else
  {
    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage));
    fc->header.size = htons (sizeof(struct TransportFlowControlMessage));
  }
 
  duration = GNUNET_TIME_absolute_get_duration (vl->last_fc_transmission);
  /* OPTIMIZE-FC-BDP: decide sane criteria on when to do this, instead of doing
     it always! */
  /* For example, we should probably ONLY do this if a bit more than
     an RTT has passed, or if the window changed "significantly" since
     then. See vl->last_fc_rtt! NOTE: to do this properly, we also
     need an estimate for the bandwidth-delay-product for the entire
     VL, as that determines "significantly". We have the delay, but
     the bandwidth statistics need to be added for the VL!*/(void) duration;
 
  if (NULL != vl->dv)
    rtt_average = calculate_rtt (vl->dv);
  else
    rtt_average = GNUNET_TIME_UNIT_FOREVER_REL;
  fc->rtt = GNUNET_TIME_relative_hton (rtt_average);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending FC seq %u to %s with new window %llu %lu %u\n",
              (unsigned int) vl->fc_seq_gen,
              GNUNET_i2s (&vl->target),
              (unsigned long long) vl->incoming_fc_window_size,
              (unsigned long) rtt_average.rel_value_us,
              vl->sync_ready);
  monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  vl->last_fc_transmission = monotime;
  fc->sync_ready = htonl ((uint32_t) vl->sync_ready);
  fc->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL);
  fc->seq = htonl (vl->fc_seq_gen++);
  fc->inbound_window_size = GNUNET_htonll (vl->incoming_fc_window_size
                                           + vl->incoming_fc_window_size_used
                                           + vl->incoming_fc_window_size_loss);
  fc->outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used);
  fc->outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size);
  fc->sender_time = GNUNET_TIME_absolute_hton (monotime);
  /* On an unconfirmed link the only queues and paths we have are, by
     definition, unvalidated ones -- that is what "unconfirmed" means.
     Requiring a validated route here is what deadlocks the pair: the peer
     has a confirmed link to us and flow-controls us, we cannot answer, so
     its @e outbound_fc_window_size stays at zero and it cannot send us a
     single byte -- not its CORE handshake, not DHT traffic -- while its
     `gnunet-transport' shows an established link with messages pending
     forever.  It reached us over that queue, so answering on it is sound. */
  rtt = route_control_message_without_fc (vl,
                                          &fc->header,
                                          (GNUNET_YES == vl->confirmed)
                                          ? RMO_DV_ALLOWED
                                          : RMO_ANYTHING_GOES);
  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us)
  {
    rtt = GNUNET_TIME_UNIT_SECONDS;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "FC retransmission to %s failed, will retry in %s\n",
                GNUNET_i2s (&vl->target),
                GNUNET_STRINGS_relative_time_to_string (rtt, GNUNET_YES));
    vl->last_fc_rtt = GNUNET_TIME_UNIT_ZERO;
  }
  else
  {
    /* OPTIMIZE-FC-BDP: rtt is not ideal, we can do better! */
    vl->last_fc_rtt = rtt;
  }
  if (NULL != vl->fc_retransmit_task)
    GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
  /* Never re-arm with (near) zero delay: @a rtt is zero whenever we have no
     RTT sample yet, which turned this into a tight send loop. */
  rtt = GNUNET_TIME_relative_max (rtt, MIN_FC_RETRANSMIT_DELAY);
  {
    /* Back off while the peer stays silent.  Retransmitting at the plain RTT
       for #MAX_FC_RETRANSMIT_COUNT rounds is a flood on a link that is not
       being answered -- and a peer that cannot answer keeps *every* one of
       its links in exactly that state, which is enough traffic to make
       transport fall behind its communicators. */
    struct GNUNET_TIME_Relative cap = FC_KEEPALIVE_INTERVAL;
 
    for (unsigned int i = 0;
         (i < vl->fc_retransmit_count) && (rtt.rel_value_us < cap.rel_value_us);
         i++)
      rtt = GNUNET_TIME_relative_multiply (rtt, 2);
    rtt = GNUNET_TIME_relative_min (rtt, cap);
  }
  vl->fc_retransmit_task =
    GNUNET_SCHEDULER_add_delayed (rtt, &task_consider_sending_fc, vl);
  if (MAX_FC_RETRANSMIT_COUNT > vl->fc_retransmit_count)
    vl->fc_retransmit_count++;
  GNUNET_free (fc);
}

References add_global_addresses(), calculate_rtt(), VirtualLink::confirmed, ctx, duration, VirtualLink::dv, dv_routes, FC_KEEPALIVE_INTERVAL, VirtualLink::fc_retransmit_count, VirtualLink::fc_retransmit_task, VirtualLink::fc_seq_gen, GNUNET_break, GNUNET_CONTAINER_multipeermap_get(), 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_relative_max(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GST_cfg, 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, lookup_neighbour(), MAX_FC_RETRANSMIT_COUNT, MIN_FC_RETRANSMIT_DELAY, VirtualLink::n, Neighbour::natted_addresses, Neighbour::number_of_addresses, AddGlobalAddressesContext::off, VirtualLink::outbound_fc_window_size, VirtualLink::outbound_fc_window_size_used, GNUNET_TIME_Relative::rel_value_us, RMO_ANYTHING_GOES, RMO_DV_ALLOWED, route_control_message_without_fc(), Neighbour::size_of_global_addresses, VirtualLink::sync_ready, VirtualLink::target, task_consider_sending_fc(), AddGlobalAddressesContext::tgnas, and Neighbour::vl.

Referenced by activate_core_visible_dv_path(), check_vl_transmission(), core_env_sent_cb(), core_fc_stalled(), 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

cls	a struct VirtualLink to work with

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

{
  struct VirtualLink *vl = cls;
  vl->fc_retransmit_task = NULL;
  consider_sending_fc (cls);
}

References consider_sending_fc(), and VirtualLink::fc_retransmit_task.

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:

get_address_without_port()

static char * get_address_without_port ( const char *  address )

static

Get the IP address without the communicator prefix and the port number.

Parameters

address

string of the form 'PREFIX-IP:PORT', for example 'tcp-92.68.150.1:55452'

Returns

string with the IP address only, or NULL if address is not of that form. Addresses reach us from remote HELLOs, so callers MUST handle NULL!

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

{
  const char *dash;
  const char *colon;
 
  if (NULL == address)
    return NULL;
  dash = strchr (address, '-');
  if (NULL == dash)
    return NULL;
  colon = strchr (dash, ':');
  if (NULL == colon)
    return NULL;
  return GNUNET_strndup (dash + 1,
                         colon - (dash + 1));
}

References address, and GNUNET_strndup.

Referenced by check_for_global_natted(), check_validation_request_pending(), create_address_entry(), find_queue_by_ip(), 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 6193 of file gnunet-service-transport.c.

{
  struct AddGlobalAddressesContext *ctx = cls;
  struct TransportGlobalNattedAddress *tgna = value;
  char *addr = (char *) &tgna[1];
  size_t alen = ntohl (tgna->address_length);
  size_t need = sizeof (struct TransportGlobalNattedAddress) + alen;
 
  /* NOTE: the address is NOT 0-terminated, it must be printed with an
     explicit precision. */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "sending address %.*s length %lu\n",
              (int) alen,
              addr,
              (unsigned long) alen);
  if (ctx->off + need > ctx->size)
  {
    GNUNET_break (0);
    return GNUNET_NO;
  }
  GNUNET_memcpy (&(ctx->tgnas[ctx->off]), tgna, need);
  ctx->off += need;
 
  return GNUNET_OK;
}

References TransportGlobalNattedAddress::address_length, ctx, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_NO, 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 11657 of file gnunet-service-transport.c.

{
  struct GNUNET_TIME_Relative ret = GNUNET_TIME_UNIT_ZERO;
  unsigned int n_hops = 0;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "calculate_rtt\n");
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "calculate_rtt %lu\n",
                (unsigned long) pos->pd.aged_rtt.rel_value_us);
    n_hops++;
    ret = GNUNET_TIME_relative_add (GNUNET_TIME_relative_multiply (pos->pd.
                                                                   aged_rtt, pos
                                                                   ->distance
                                                                   + 2), ret);
  }
 
  if (0 == n_hops)
    return GNUNET_TIME_UNIT_FOREVER_REL;
  return ret;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_TIME_relative_add(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, 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

vl	virtual link where we should check for transmission

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

{
  struct Neighbour *n = vl->n;
  struct DistanceVector *dv = vl->dv;
  struct GNUNET_TIME_Absolute now;
  struct VirtualLink *vl_next_hop;
  int elig;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "check_vl_transmission to target %s\n",
              GNUNET_i2s (&vl->target));
  /* Check that we have an eligible pending message!
     (cheaper than having #transmit_on_queue() find out!) */
  elig = GNUNET_NO;
  for (struct PendingMessage *pm = vl->pending_msg_head; NULL != pm;
       pm = pm->next_vl)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "check_vl_transmission loop\n");
    if (NULL != pm->qe)
      continue;   /* not eligible, is in a queue! */
    if (pm->bytes_msg + vl->outbound_fc_window_size_used >
        vl->outbound_fc_window_size)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Stalled message %" PRIu64
                  " transmission on VL %s due to flow control: %llu < %llu\n",
                  pm->logging_uuid,
                  GNUNET_i2s (&vl->target),
                  (unsigned long long) vl->outbound_fc_window_size,
                  (unsigned long long) (pm->bytes_msg
                                        + vl->outbound_fc_window_size_used));
      consider_sending_fc (vl);
      return;     /* We have a message, but flow control says "nope" */
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Target window on VL %s not stalled. Scheduling transmission on queue\n",
                GNUNET_i2s (&vl->target));
    /* Notify queues at direct neighbours that we are interested */
    now = GNUNET_TIME_absolute_get ();
    if (NULL != n)
    {
      for (struct Queue *queue = n->queue_head; NULL != queue;
           queue = queue->next_neighbour)
      {
        if ((GNUNET_YES == queue->idle) &&
            (queue->validated_until.abs_value_us > now.abs_value_us))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Direct neighbour %s not stalled\n",
                      GNUNET_i2s (&n->pid));
          schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                      queue,
                                      GNUNET_SCHEDULER_PRIORITY_DEFAULT);
          elig = GNUNET_YES;
        }
        else
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Neighbour Queue QID: %u (%u) busy or invalid\n",
                      queue->qid,
                      queue->idle);
      }
    }
    /* Notify queues via DV that we are interested */
    if (NULL != dv)
    {
      /* Do DV with lower scheduler priority, which effectively means that
         IF a neighbour exists and is available, we prefer it. */
      for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
           pos = pos->next_dv)
      {
        struct Neighbour *nh_iter = pos->next_hop;
 
 
        if (pos->path_valid_until.abs_value_us <= now.abs_value_us)
          continue;   /* skip this one: path not validated */
        else
        {
          /* The next hop is a neighbour we have queues to; it need not have
             a virtual link of its own, and then there is no window of it to
             respect either. */
          vl_next_hop = lookup_virtual_link (&nh_iter->pid);
          if ((NULL != vl_next_hop) &&
              (pm->bytes_msg + vl_next_hop->outbound_fc_window_size_used >
               vl_next_hop->outbound_fc_window_size))
          {
            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        "Stalled message %" PRIu64
                        " transmission on next hop %s due to flow control: %llu < %llu\n",
                        pm->logging_uuid,
                        GNUNET_i2s (&vl_next_hop->target),
                        (unsigned long
                         long) vl_next_hop->outbound_fc_window_size,
                        (unsigned long long) (pm->bytes_msg
                                              + vl_next_hop->
                                              outbound_fc_window_size_used));
            consider_sending_fc (vl_next_hop);
            continue; /* We have a message, but flow control says "nope" for the first hop of this path */
          }
          for (struct Queue *queue = nh_iter->queue_head; NULL != queue;
               queue = queue->next_neighbour)
            if ((GNUNET_YES == queue->idle) &&
                (queue->validated_until.abs_value_us > now.abs_value_us))
            {
              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                          "Next hop neighbour %s not stalled\n",
                          GNUNET_i2s (&nh_iter->pid));
              schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                          queue,
                                          GNUNET_SCHEDULER_PRIORITY_BACKGROUND);
              elig = GNUNET_YES;
            }
            else
              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                          "DV Queue QID: %u (%u) busy or invalid\n",
                          queue->qid,
                          queue->idle);
        }
      }
    }
    if (GNUNET_YES == elig)
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Eligible message %" PRIu64 " of size %u to %s: %llu/%llu\n",
                  pm->logging_uuid,
                  pm->bytes_msg,
                  GNUNET_i2s (&vl->target),
                  (unsigned long long) vl->outbound_fc_window_size,
                  (unsigned long long) (pm->bytes_msg
                                        + vl->outbound_fc_window_size_used));
    break;
  }
}

References GNUNET_TIME_Absolute::abs_value_us, consider_sending_fc(), VirtualLink::dv, DistanceVector::dv_head, 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, VirtualLink::outbound_fc_window_size, VirtualLink::outbound_fc_window_size_used, VirtualLink::pending_msg_head, Neighbour::pid, 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

cls	the client
obm	the send message that was sent

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

{
  struct TransportClient *tc = cls;
  struct PendingMessage *pm;
  const struct GNUNET_MessageHeader *obmm;
  uint32_t bytes_msg;
  struct VirtualLink *vl;
  enum GNUNET_MQ_PriorityPreferences pp;
 
  GNUNET_assert (CT_CORE == tc->type);
  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
  bytes_msg = ntohs (obmm->size);
  pp = ntohl (obm->priority);
  vl = lookup_virtual_link (&obm->peer);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Don't have %s as a neighbour (anymore).\n",
                GNUNET_i2s (&obm->peer));
    /* Failure: don't have this peer as a neighbour (anymore).
       Might have gone down asynchronously, so this is NOT
       a protocol violation by CORE. Still count the event,
       as this should be rare. */
    /* Precisely because this is not a protocol violation we leave the
       client's `struct Neighbour' -- and its send window -- in place, so we
       owe it the SEND_OK for the message we are dropping here.  Without it
       the window shrinks by one every time this happens and never grows
       back; after #SEND_WINDOW_SIZE such drops #mq_send_impl() parks every
       further message for this peer forever ("Flow control delays
       transmission to CORE until we see SEND_OK") and CORE goes mute
       towards a peer it still believes it is connected to -- while
       continuing to receive from it, so its own idle timeout is what
       eventually reports the peer down. */
    send_ok_to_client (tc, &obm->peer);
    GNUNET_SERVICE_client_continue (tc->client);
    GNUNET_STATISTICS_update (GST_stats,
                              "# messages dropped (neighbour unknown)",
                              1,
                              GNUNET_NO);
    return;
  }
 
  pm = GNUNET_malloc (sizeof(struct PendingMessage) + bytes_msg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "1 created pm %p storing vl %p\n",
              pm,
              vl);
  pm->logging_uuid = logging_uuid_gen++;
  pm->prefs = pp;
  pm->client = tc;
  pm->vl = vl;
  pm->bytes_msg = bytes_msg;
  memcpy (&pm[1], obmm, bytes_msg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending message of type %u  with %u bytes as <%" PRIu64
              "> to %s\n",
              ntohs (obmm->type),
              bytes_msg,
              pm->logging_uuid,
              GNUNET_i2s (&obm->peer));
  GNUNET_CONTAINER_MDLL_insert (client,
                                tc->details.core.pending_msg_head,
                                tc->details.core.pending_msg_tail,
                                pm);
  GNUNET_CONTAINER_MDLL_insert (vl,
                                vl->pending_msg_head,
                                vl->pending_msg_tail,
                                pm);
  check_vl_transmission (vl);
  GNUNET_SERVICE_client_continue (tc->client);
}

References PendingMessage::bytes_msg, check_vl_transmission(), PendingMessage::client, 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, PendingMessage::logging_uuid, logging_uuid_gen, lookup_virtual_link(), OutboundMessage::peer, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, PendingMessage::prefs, OutboundMessage::priority, send_ok_to_client(), GNUNET_MessageHeader::size, tc, GNUNET_MessageHeader::type, and PendingMessage::vl.

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

cls	the client
cb	the send message that was sent

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

{
  struct Neighbour *n;
  struct VirtualLink *vl;
  struct TransportClient *tc = cls;
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &cb[1];
  uint16_t isize = ntohs (inbox->size);
  const char *is = ((const char *) &cb[1]) + isize;
  size_t slen = strlen (is) + 1;
  char
    mbuf[slen + isize
         + sizeof(struct
                  TransportBackchannelEncapsulationMessage)] GNUNET_ALIGN;
  struct TransportBackchannelEncapsulationMessage *be =
    (struct TransportBackchannelEncapsulationMessage *) mbuf;
 
  /* 0-termination of 'is' was checked already in
   #check_communicator_backchannel() */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Preparing backchannel transmission to %s:%s of type %u and size %u\n",
              GNUNET_i2s (&cb->pid),
              is,
              ntohs (inbox->type),
              ntohs (inbox->size));
  /* encapsulate and encrypt message */
  be->header.type =
    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION);
  be->header.size = htons (sizeof(mbuf));
  memcpy (&be[1], inbox, isize);
  memcpy (&mbuf[sizeof(struct TransportBackchannelEncapsulationMessage)
                + isize],
          is,
          strlen (is) + 1);
  // route_control_message_without_fc (&cb->pid, &be->header, RMO_DV_ALLOWED);
  vl = lookup_virtual_link (&cb->pid);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    route_control_message_without_fc (vl, &be->header, RMO_DV_ALLOWED);
  }
  else
  {
    /* Use route via neighbour */
    n = lookup_neighbour (&cb->pid);
    if (NULL != n)
      route_via_neighbour (
        n,
        &be->header,
        RMO_NONE);
  }
  GNUNET_SERVICE_client_continue (tc->client);
}

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

cls	the client
aam	the send message that was sent

Returns

GNUNET_OK if message is well-formed

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

{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_MQ_check_zero_termination (aam);
  return GNUNET_OK;
}

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

cls	an struct AddressListEntry *

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

{
  struct AddressListEntry *ale = cls;
  const char *dash;
  char *address_uri;
  char *prefix;
  unsigned int add_success;
 
  if ((GNUNET_YES == in_shutdown) || (NULL == pils))
  {
    ale->st = NULL;
    return;
  }
  if (NULL == GNUNET_PILS_get_identity (pils))
  {
    /* Do NOT poll at 1kHz: that burns CPU and keeps the scheduler task
       list non-empty, which prevents the service from ever exiting. */
    ale->pils_backoff = GNUNET_TIME_STD_BACKOFF (ale->pils_backoff);
    ale->st = GNUNET_SCHEDULER_add_delayed (ale->pils_backoff,
                                            &store_pi,
                                            ale);
    return;
  }
  ale->pils_backoff = GNUNET_TIME_UNIT_ZERO;
  prefix = GNUNET_HELLO_address_to_prefix (ale->address);
  dash = strchr (ale->address, '-');
  GNUNET_assert (NULL != dash);
  dash++;
  GNUNET_asprintf (&address_uri,
                   "%s://%s",
                   prefix,
                   dash);
  GNUNET_free (prefix);
  ale->st = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Storing our address `%s' in peerstore until %s!\n",
              ale->address,
              GNUNET_STRINGS_absolute_time_to_string (hello_mono_time));
  add_success = GNUNET_HELLO_builder_add_address (GST_my_hello,
                                                  address_uri);
  /* NOTE: #GNUNET_HELLO_builder_add_address() answers GNUNET_NO for an
     address that is already in the builder, and on every call after the
     first one for a given address that is exactly what happens: nothing
     ever removes an address from @a GST_my_hello except
     #handle_del_address().  This function is the *refresh* cycle --
     #peerstore_store_own_cb() re-arms it at a quarter of the address'
     expiration -- so bailing out on GNUNET_NO here stopped the refresh
     after precisely one round.  Our own HELLO then expired
     (#GNUNET_HELLO_ADDRESS_EXPIRATION, twelve hours) and was never
     renewed: peers can no longer learn how to reach us, and a link that
     drops after that never comes back.  Only GNUNET_SYSERR -- a malformed
     URI, which retrying cannot fix -- is a reason not to store. */
  if (GNUNET_SYSERR == add_success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Not storing our address `%s': not a valid HELLO URI\n",
                address_uri);
    GNUNET_free (address_uri);
    return;
  }
  GNUNET_log ((GNUNET_NO == add_success) ?
              GNUNET_ERROR_TYPE_DEBUG : GNUNET_ERROR_TYPE_INFO,
              "%s our address `%s' in PEERSTORE\n",
              (GNUNET_NO == add_success) ? "Refreshing" : "Storing",
              address_uri);
  // FIXME hello_mono_time used here?? What about expiration in ale?
  pils_sign_address (ale,
                     hello_mono_time);
  // TODO keep track of op and potentially cancel/clean
  GNUNET_free (address_uri);
}

References AddressListEntry::address, GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_address_to_prefix(), GNUNET_HELLO_builder_add_address(), GNUNET_log, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GST_my_hello, hello_mono_time, in_shutdown, pils, AddressListEntry::pils_backoff, pils_sign_address(), prefix, AddressListEntry::st, and store_pi().

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

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

{
  struct PilsAddressSignContext *pc = cls;
 
  GNUNET_assert (NULL == pc->req);
  /* The store completed; the handle is dead and must not be cancelled
     later by #free_address_list_entry(). */
  pc->ale->shc = NULL;
  pc->ale->pc = NULL;
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to store our address `%s' with peerstore\n",
                pc->ale->address);
    if (NULL == pc->ale->st)
    {
      pc->ale->st = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                  &store_pi,
                                                  pc->ale);
    }
  }
  GNUNET_free (pc);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_SECONDS, pc, and store_pi().

Referenced by pils_sign_hello_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

pils_sign_hello_cb()

static void pils_sign_hello_cb ( void *  cls, const struct GNUNET_PeerIdentity *  pid, const struct GNUNET_CRYPTO_EddsaSignature *  sig  )

static

Get HELLO signature and create message to store in PEERSTORE.

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

{
  struct PilsAddressSignContext *pc = cls;
  struct GNUNET_MQ_Envelope *env;
  const struct GNUNET_MessageHeader *msg;
 
  pc->req->op = NULL;
  GNUNET_CONTAINER_DLL_remove (pils_requests_head,
                               pils_requests_tail,
                               pc->req);
  GNUNET_free (pc->req);
  pc->req = NULL;
  env = GNUNET_HELLO_builder_to_env (
    GST_my_hello,
    pid,
    sig,
    pc->et);
  msg = GNUNET_MQ_env_get_msg (env);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "store_pi 1\n");
  pc->ale->shc = GNUNET_PEERSTORE_hello_add (peerstore,
                                             msg,
                                             shc_cont,
                                             pc);
  GNUNET_free (env);
}

References env, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_builder_to_env(), GNUNET_log, GNUNET_MQ_env_get_msg(), GNUNET_PEERSTORE_hello_add(), GST_my_hello, msg, pc, peerstore, pils_requests_head, pils_requests_tail, and shc_cont().

Referenced by peerstore_store_own_cb().

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

cls	a struct AddressListEntry
success	GNUNET_YES if peerstore was successful

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

{
  struct PilsAddressSignContext *pc = cls;
 
  pc->ale->sc = NULL;
  if (GNUNET_YES != success)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store our own address `%s' in peerstore!\n",
                pc->ale->address);
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Successfully stored our own address `%s' in peerstore!\n",
                pc->ale->address);
  /* refresh period is 1/4 of expiration time, that should be plenty
     without being excessive. */
  if (NULL == pc->ale->st)
  {
    /* @e expiration comes straight off the wire in ADD_ADDRESS and is not
       validated anywhere, so a communicator reporting a very short (or
       zero) lifetime would have us re-sign the HELLO and store it again on
       the next scheduler pass, forever.  That is an EdDSA signature and a
       PEERSTORE round trip per iteration. */
    pc->ale->st =
      GNUNET_SCHEDULER_add_delayed (
        GNUNET_TIME_relative_max (
          MIN_ADDRESS_REFRESH_INTERVAL,
          GNUNET_TIME_relative_divide (pc->ale->expiration,
                                       4ULL)),
        &store_pi,
        pc->ale);
  }
 
  /* Now we have to update our HELLO! */
  pc->et = GNUNET_TIME_relative_to_absolute (GNUNET_HELLO_ADDRESS_EXPIRATION);
  pc->req = GNUNET_new (struct PilsRequest);
  GNUNET_CONTAINER_DLL_insert (pils_requests_head,
                               pils_requests_tail,
                               pc->req);
  pc->req->op = GNUNET_PILS_sign_hello (pils,
                                        GST_my_hello,
                                        pc->et,
                                        &pils_sign_hello_cb,
                                        pc);
}

References GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_HELLO_ADDRESS_EXPIRATION, GNUNET_log, GNUNET_new, GNUNET_PILS_sign_hello(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_max(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GST_my_hello, MIN_ADDRESS_REFRESH_INTERVAL, pc, pils, pils_requests_head, pils_requests_tail, pils_sign_hello_cb(), and store_pi().

Referenced by store_signed_address().

Here is the call graph for this function:

Here is the caller graph for this function:

store_signed_address()

static void store_signed_address ( struct PilsAddressSignContext *  pc, const struct GNUNET_PeerIdentity *  pid, const struct GNUNET_CRYPTO_EddsaSignature *  sig  )

static

Turn the signed address into a HELLO URI and hand it to PEERSTORE.

Parameters

pc	the sign-and-store chain this belongs to
pid	our peer identity
sig	signature over the address

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

{
  char *sig_str;
  void *result;
  size_t result_size;
 
  sig_str = NULL;
  (void) GNUNET_STRINGS_base64_encode (sig, sizeof(*sig), &sig_str);
  result_size =
    1 + GNUNET_asprintf (
      (char **) &result,
      "%s;%llu;%u;%s",
      sig_str,
      (unsigned long long) pc->et.abs_value_us,
      (unsigned int) pc->ale->nt,
      pc->ale->address);
  GNUNET_free (sig_str);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Build our HELLO URI `%s'\n",
              (char*) result);
 
  GNUNET_free (pc->ale->signed_address);
  pc->ale->signed_address = result;
  pc->ale->signed_address_len = result_size;
  struct GNUNET_TIME_Absolute expiration;
 
  expiration = GNUNET_TIME_relative_to_absolute (pc->ale->expiration);
  pc->ale->sc = GNUNET_PEERSTORE_store (peerstore,
                                        "transport",
                                        pid,
                                        GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY,
                                        result,
                                        result_size,
                                        expiration,
                                        GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
                                        &peerstore_store_own_cb,
                                        pc);
}

References expiration, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEERSTORE_store(), GNUNET_PEERSTORE_STOREOPTION_MULTIPLE, GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY, GNUNET_STRINGS_base64_encode(), GNUNET_TIME_relative_to_absolute(), pc, peerstore, peerstore_store_own_cb(), and result.

Referenced by pils_sign_address().

Here is the call graph for this function:

Here is the caller graph for this function:

pils_sign_address()

void pils_sign_address	(	struct AddressListEntry *	ale,
		struct GNUNET_TIME_Absolute	mono_time
	)

Build address record by signing raw information with private key of the peer identity.

Parameters

handle	handle to the PILS service
address	text address at communicator to sign
nt	network type of address
mono_time	monotonic time at which address was valid
cb	callback called once the signature is ready
cb_cls	closure to the cb callback

Returns

handle to the operation, NULL on error

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

{
  struct SignedAddress sa;
  struct PilsAddressSignContext *pc;
  struct GNUNET_CRYPTO_EddsaSignature sig;
  const struct GNUNET_PeerIdentity *my_identity;
 
  sa.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS);
  sa.purpose.size = htonl (sizeof(sa));
  sa.mono_time = GNUNET_TIME_absolute_hton (mono_time);
  GNUNET_CRYPTO_hash (ale->address, strlen (ale->address), &sa.addr_hash);
  /* Only ever one chain per entry: the previous one (if any) still holds a
     pointer to @a ale and must be torn down first. */
  cancel_address_store (ale);
  my_identity = GNUNET_PILS_get_identity (pils);
  if ((NULL == my_identity) ||
      (GNUNET_OK != sign_by_my_identity (&sa.purpose, &sig)))
  {
    /* Nothing else re-arms @e st: #store_pi() cleared it before calling us,
       and the only other thing that sets it is #peerstore_store_own_cb(),
       which is on the far side of the store we just failed to start.  So a
       single failure to sign used to end the refresh cycle for this address
       for the rest of the process' life. */
    if (NULL == ale->st)
    {
      ale->pils_backoff = GNUNET_TIME_STD_BACKOFF (ale->pils_backoff);
      ale->st = GNUNET_SCHEDULER_add_delayed (ale->pils_backoff,
                                              &store_pi,
                                              ale);
    }
    return;
  }
  pc = GNUNET_new (struct PilsAddressSignContext);
  pc->ale = ale;
  pc->et = mono_time;
  ale->pc = pc;
  store_signed_address (pc, my_identity, &sig);
}

References AddressListEntry::address, cancel_address_store(), GNUNET_CRYPTO_hash(), GNUNET_new, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_ADDRESS, GNUNET_TIME_absolute_hton(), GNUNET_TIME_STD_BACKOFF, SignedAddress::mono_time, my_identity, pc, AddressListEntry::pc, pils, AddressListEntry::pils_backoff, GNUNET_CRYPTO_SignaturePurpose::purpose, SignedAddress::purpose, sign_by_my_identity(), GNUNET_CRYPTO_SignaturePurpose::size, AddressListEntry::st, store_pi(), and store_signed_address().

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

{
  struct AddressListEntry *ale;
  char *address_without_port;
 
  ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen);
  ale->tc = tc;
  ale->address = (const char *) &ale[1];
  ale->expiration = expiration;
  ale->aid = aid;
  ale->nt = nt;
  memcpy (&ale[1], address, slen);
  address_without_port = get_address_without_port (ale->address);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Is this %s a local address (%s)\n",
              (NULL == address_without_port) ? "<unparsable>"
              : address_without_port,
              ale->address);
  if ((NULL == address_without_port) ||
      (0 != strcmp ("127.0.0.1", address_without_port)))
  {
    if (NULL != ale->st)
    {
      GNUNET_SCHEDULER_cancel (ale->st);
    }
    ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
  }
  GNUNET_free (address_without_port);
 
  return ale;
}

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(), GNUNET_SCHEDULER_cancel(), 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:

feed_addresses_to_pils()

static void feed_addresses_to_pils ( void *  cls )

static

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

{
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Feeding addresses to PILS\n");
  pils_feed_task = NULL;
 
  GNUNET_PILS_feed_addresses (pils,
                              GST_my_hello);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_PILS_feed_addresses(), GST_my_hello, pils, and pils_feed_task.

Referenced by handle_add_address(), and handle_del_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

cls	the client
aam	the send message that was sent

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

{
  struct TransportClient *tc = cls;
  struct AddressListEntry *ale;
  size_t slen;
  char *address;
 
  /* 0-termination of &aam[1] was checked in #check_add_address */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Communicator added address `%s'!\n",
              (const char *) &aam[1]);
  slen = ntohs (aam->header.size) - sizeof(*aam);
  address = GNUNET_malloc (slen);
  memcpy (address, &aam[1], slen);
  ale = create_address_entry (tc,
                              GNUNET_TIME_relative_ntoh (aam->expiration),
                              ntohl (aam->nt),
                              address,
                              aam->aid,
                              slen);
  GNUNET_CONTAINER_DLL_insert (tc->details.communicator.addr_head,
                               tc->details.communicator.addr_tail,
                               ale);
  {
    for (struct AddressListEntry *iter = tc->details.communicator.addr_head;
         NULL != iter;
         iter = iter->next)
    {
      char *address_uri;
      const char *dash = strchr (iter->address, '-');
      char *prefix = GNUNET_HELLO_address_to_prefix (iter->address);
      GNUNET_assert (NULL != dash);
      dash++;
      GNUNET_asprintf (&address_uri,
                       "%s://%s",
                       prefix,
                       dash);
      GNUNET_free (prefix);
      GNUNET_HELLO_builder_add_address (GST_my_hello, address_uri);
      GNUNET_free (address_uri);
    }
    if (NULL != pils_feed_task)
      GNUNET_SCHEDULER_cancel (pils_feed_task);
    pils_feed_task = GNUNET_SCHEDULER_add_delayed (PILS_FEED_ADDRESSES_DELAY,
                                                   &feed_addresses_to_pils,
                                                   NULL);
  }
  GNUNET_SERVICE_client_continue (tc->client);
  GNUNET_free (address);
}

References address, GNUNET_TRANSPORT_AddAddressMessage::aid, create_address_entry(), GNUNET_TRANSPORT_AddAddressMessage::expiration, feed_addresses_to_pils(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_to_prefix(), GNUNET_HELLO_builder_add_address(), GNUNET_log, GNUNET_malloc, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_TIME_relative_ntoh(), GST_my_hello, GNUNET_TRANSPORT_AddAddressMessage::header, GNUNET_TRANSPORT_AddAddressMessage::nt, PILS_FEED_ADDRESSES_DELAY, pils_feed_task, prefix, 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

cls	the client
dam	the send message that was sent

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

{
  struct TransportClient *tc = cls;
  struct AddressListEntry *alen;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  for (struct AddressListEntry *ale = tc->details.communicator.addr_head;
       NULL != ale;
       ale = alen)
  {
    alen = ale->next;
    if (dam->aid != ale->aid)
      continue;
    GNUNET_assert (ale->tc == tc);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Communicator deleted address `%s'!\n",
                ale->address);
    GNUNET_HELLO_builder_del_address (GST_my_hello,
                                      ale->address);
    if (NULL != pils_feed_task)
      GNUNET_SCHEDULER_cancel (pils_feed_task);
    pils_feed_task = GNUNET_SCHEDULER_add_delayed (PILS_FEED_ADDRESSES_DELAY,
                                                   &feed_addresses_to_pils,
                                                   NULL);
    free_address_list_entry (ale);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Communicator removed address we did not even have.\n");
  GNUNET_SERVICE_client_continue (tc->client);
  // GNUNET_SERVICE_client_drop (tc->client);
}

References GNUNET_TRANSPORT_DelAddressMessage::aid, CT_COMMUNICATOR, feed_addresses_to_pils(), free_address_list_entry(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_HELLO_builder_del_address(), GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GST_my_hello, AddressListEntry::next, PILS_FEED_ADDRESSES_DELAY, pils_feed_task, 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

cmc	context for demultiplexing
msg	message to demultiplex

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

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (fragment_box,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT,
                           struct TransportFragmentBoxMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (reliability_box,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX,
                           struct TransportReliabilityBoxMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (reliability_ack,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK,
                           struct TransportReliabilityAckMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (backchannel_encapsulation,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION,
                           struct TransportBackchannelEncapsulationMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (dv_learn,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN,
                           struct TransportDVLearnMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (dv_box,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX,
                           struct TransportDVBoxMessage,
                           cmc),
    GNUNET_MQ_hd_var_size (flow_control,
                           GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL,
                           struct TransportFlowControlMessage,
                           cmc),
    GNUNET_MQ_hd_fixed_size (
      validation_challenge,
      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE,
      struct TransportValidationChallengeMessage,
      cmc),
    GNUNET_MQ_hd_fixed_size (
      validation_response,
      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE,
      struct TransportValidationResponseMessage,
      cmc),
    GNUNET_MQ_handler_end () };
  int ret;
  const struct GNUNET_MessageHeader *msg = cmc->mh;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling message of type %u with %u bytes\n",
              (unsigned int) ntohs (msg->type),
              (unsigned int) ntohs (msg->size));
  /* @a handlers only covers the encapsulations *we* add; anything else is a
     payload for CORE and leaves through #handle_raw_message() below. So
     #GNUNET_NO is the common case here -- one per delivered CORE message --
     and not something to log about, which is why this is the "try" variant. */
  ret = GNUNET_MQ_try_handle_message (handlers, msg);
  if (GNUNET_SYSERR == ret)
  {
    /* @a msg is the message a *remote peer* sent us: #handle_incoming_msg()
       points @e mh into the payload of the
       #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG the communicator
       delivered, and every other caller unwraps it from remote traffic as
       well.  So failing a check here is that peer's protocol violation, and
       it says nothing at all about the communicator that carried it.
 
       Dropping the client therefore punishes the wrong party, and it
       punishes it hard: #GNUNET_SERVICE_client_drop() disconnects the
       communicator *process*, which takes down every queue it owns and thus
       every neighbour reachable through it.  One malformed DV box on a
       shared UDP communicator disconnects every peer we have on it, CORE
       tears the sessions down, and the key exchanges that would rebuild
       them have to wait for the communicator to come back and revalidate.
       Since the offending bytes arrive from the network, any peer can do
       this to us at will, repeatedly.
 
       Drop the message and keep the communicator: resume it exactly as the
       success path does, so it still gets its flow-control ACK and its
       GNUNET_SERVICE_client_continue(). */
    GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              "# malformed messages discarded",
                              1,
                              GNUNET_NO);
    finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  if (GNUNET_NO == ret)
  {
    /* unencapsulated 'raw' message */
    handle_raw_message (cmc, msg);
  }
}

References finish_cmc_handling_with_continue(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, 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_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_try_handle_message(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, GST_stats, handle_raw_message(), handlers, CommunicatorMessageContext::mh, msg, ret, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by backtalker_monotime_cb(), decaps_dv_box_cont(), 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

cls	a struct CoreSentContext

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

{
  struct CoreSentContext *ctx = cls;
  struct VirtualLink *vl = ctx->vl;
 
  if (NULL == vl)
  {
    /* lost the link in the meantime, ignore */
    GNUNET_free (ctx);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, ctx);
  GNUNET_assert (vl->incoming_fc_window_size_ram >= ctx->size);
  vl->incoming_fc_window_size_ram -= ctx->size;
  vl->incoming_fc_window_size_used += ctx->isize;
  consider_sending_fc (vl);
  GNUNET_free (ctx);
}

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:

core_fc_stalled()

static void core_fc_stalled ( void *  cls )

static

CORE never returned the flow control credit for the messages we handed it for cls, so the communicators that delivered them are still waiting on us.

A communicator is shared by every peer it talks to, so one stuck link would otherwise take all of them down with it – and nothing else ever unblocks this: handle_client_recv_ok() is the only thing that drains cmc_head, and it needs the RECV_OK that is not coming.

Give up on the parked messages and start the window over. Note that a late RECV_OK can then push core_recv_window above RECV_WINDOW_SIZE; that merely weakens flow control for a while, which is what the existing unconditional ‘+= delta’ does anyway.

The bytes we drop here need no accounting: the next FLOW_CONTROL exchange derives incoming_fc_window_size_loss from the difference between what the sender says it sent and what we counted as used, so the peer's window is corrected automatically.

Parameters

cls	the struct VirtualLink whose CORE window is stuck

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

{
  struct VirtualLink *vl = cls;
  struct CommunicatorMessageContext *cmc;
 
  vl->core_fc_stall_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "CORE did not acknowledge messages from %s within %s; "
              "releasing the flow control credit anyway\n",
              GNUNET_i2s (&vl->target),
              GNUNET_STRINGS_relative_time_to_string (CORE_FC_STALL_TIMEOUT,
                                                      GNUNET_YES));
  GNUNET_STATISTICS_update (GST_stats,
                            "# CORE flow control stalls",
                            1,
                            GNUNET_NO);
  while (NULL != (cmc = vl->cmc_tail))
    release_stalled_cmc (vl, cmc);
  vl->core_recv_window = RECV_WINDOW_SIZE;
  consider_sending_fc (vl);
}

References VirtualLink::cmc_tail, consider_sending_fc(), VirtualLink::core_fc_stall_task, CORE_FC_STALL_TIMEOUT, VirtualLink::core_recv_window, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, GST_stats, RECV_WINDOW_SIZE, release_stalled_cmc(), and VirtualLink::target.

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

{
  uint16_t size = ntohs (mh->size);
  int have_core;
 
  if (vl->incoming_fc_window_size_ram > UINT_MAX - size)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (FC arithmetic overflow)",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "CORE messages of type %u with %u bytes dropped (FC arithmetic overflow)\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  if (vl->incoming_fc_window_size_ram + size > vl->available_fc_window_size)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (FC window overflow)",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "CORE messages of type %u with %u bytes dropped (FC window overflow)\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
 
  /* Forward to all CORE clients */
  have_core = GNUNET_NO;
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    struct GNUNET_MQ_Envelope *env;
    struct InboundMessage *im;
    struct CoreSentContext *ctx;
 
    if (CT_CORE != tc->type)
      continue;
    vl->incoming_fc_window_size_ram += size;
    env = GNUNET_MQ_msg_extra (im, size, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
    ctx = GNUNET_new (struct CoreSentContext);
    ctx->vl = vl;
    ctx->size = size;
    ctx->isize = (GNUNET_NO == have_core) ? size : 0;
    have_core = GNUNET_YES;
    GNUNET_CONTAINER_DLL_insert (vl->csc_head, vl->csc_tail, ctx);
    GNUNET_MQ_notify_sent (env, &core_env_sent_cb, ctx);
    im->peer = cmc->im.sender;
    memcpy (&im[1], mh, size);
    GNUNET_MQ_send (tc->mq, env);
    vl->core_recv_window--;
  }
  if (GNUNET_NO == have_core)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Dropped message to CORE: no CORE client connected!\n");
    /* Nevertheless, count window as used, as it is from the
       perspective of the other peer! */
    vl->incoming_fc_window_size_used += size;
    /* TODO-M1 */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Dropped message of type %u with %u bytes to CORE: no CORE client connected!\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Delivered message from %s of type %u to CORE recv window %d\n",
              GNUNET_i2s (&cmc->im.sender),
              ntohs (mh->type),
              vl->core_recv_window);
  if (vl->core_recv_window > 0)
  {
    if (GNUNET_YES == free_cmc)
      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
    return;
  }
  /* CORE ran out of receive window for *this* link.  Withhold the
     per-message ACK -- that is what expresses the backpressure -- but
     resume the client immediately.  The client is the communicator
     *process*, which carries every peer we reach through it, and a
     communicator we stop reading from does not stop receiving: it starts
     discarding, see "transport is too slow" in
     #GNUNET_TRANSPORT_communicator_receive().  Discarding is precisely
     what we cannot afford here, because among the messages dropped are
     the ones CORE needs in order to reopen the window it is waiting on. */
  if (GNUNET_YES == free_cmc)
  {
    resume_cmc_client (cmc);
    GNUNET_CONTAINER_DLL_insert (vl->cmc_head, vl->cmc_tail, cmc);
    vl->cmc_count++;
    /* Nothing stalls the producer any more, so bound the list ourselves. */
    while (MAX_STALLED_CMCS < vl->cmc_count)
      release_stalled_cmc (vl, vl->cmc_tail);
    /* ... and do not withhold the ACKs forever: see #core_fc_stalled(). */
    if (NULL == vl->core_fc_stall_task)
      vl->core_fc_stall_task =
        GNUNET_SCHEDULER_add_delayed (CORE_FC_STALL_TIMEOUT,
                                      &core_fc_stalled,
                                      vl);
  }
}

References VirtualLink::available_fc_window_size, clients_head, VirtualLink::cmc_count, VirtualLink::cmc_head, VirtualLink::cmc_tail, core_env_sent_cb(), VirtualLink::core_fc_stall_task, CORE_FC_STALL_TIMEOUT, core_fc_stalled(), 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_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_YES, GST_stats, CommunicatorMessageContext::im, VirtualLink::incoming_fc_window_size_ram, VirtualLink::incoming_fc_window_size_used, mh, InboundMessage::peer, release_stalled_cmc(), resume_cmc_client(), 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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
mh	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  // struct CommunicatorMessageContext *cmc_copy =
  // GNUNET_new (struct CommunicatorMessageContext);
  struct GNUNET_MessageHeader *mh_copy;
  struct RingBufferEntry *rbe;
  struct VirtualLink *vl;
  uint16_t size = ntohs (mh->size);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling raw message of type %u with %u bytes\n",
              (unsigned int) ntohs (mh->type),
              (unsigned int) ntohs (mh->size));
 
  if ((size > UINT16_MAX - sizeof(struct InboundMessage)) ||
      (size < sizeof(struct GNUNET_MessageHeader)))
  {
    /* @a mh was unwrapped from what a *remote peer* sent us, so a bad size
       is that peer's protocol violation and says nothing about the
       communicator that carried it.  Dropping the client here disconnects
       the communicator process and with it every neighbour reachable
       through it -- see the rationale in #demultiplex_with_cmc(). */
    GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (bad size)",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  vl = lookup_virtual_link (&cmc->im.sender);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    /* FIXME: sender is giving us messages for CORE but we don't have
       the link up yet! I *suspect* this can happen right now (i.e.
       sender has verified us, but we didn't verify sender), but if
       we pass this on, CORE would be confused (link down, messages
       arrive).  We should investigate more if this happens often,
       or in a persistent manner, and possibly do "something" about
       it. Thus logging as error for now. */
 
    mh_copy = GNUNET_malloc (size);
    rbe = GNUNET_new (struct RingBufferEntry);
    rbe->cmc = cmc;
    /*cmc_copy->tc = cmc->tc;
       cmc_copy->im = cmc->im;*/
    GNUNET_memcpy (mh_copy, mh, size);
 
    rbe->mh = mh_copy;
 
    if (GNUNET_YES == is_ring_buffer_full)
    {
      struct RingBufferEntry *rbe_old = ring_buffer[ring_buffer_head];
      GNUNET_free (rbe_old->cmc);
      GNUNET_free (rbe_old->mh);
      GNUNET_free (rbe_old);
    }
    ring_buffer[ring_buffer_head] = rbe;// cmc_copy;
    // cmc_copy->mh = (const struct GNUNET_MessageHeader *) mh_copy;
    cmc->mh = (const struct GNUNET_MessageHeader *) mh_copy;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Storing message for %s and type %u (%u) in ring buffer head %u is full %u\n",
                GNUNET_i2s (&cmc->im.sender),
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh_copy->type),
                ring_buffer_head,
                is_ring_buffer_full);
    if (RING_BUFFER_SIZE - 1 == ring_buffer_head)
    {
      ring_buffer_head = 0;
      is_ring_buffer_full = GNUNET_YES;
    }
    else
      ring_buffer_head++;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u items stored in ring buffer\n",
                GNUNET_YES == is_ring_buffer_full ? RING_BUFFER_SIZE :
                ring_buffer_head);
 
    /*GNUNET_break_op (0);
    GNUNET_STATISTICS_update (GST_stats,
                              "# CORE messages dropped (virtual link still down)",
                              1,
                              GNUNET_NO);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "CORE messages of type %u with %u bytes dropped (virtual link still down)\n",
                (unsigned int) ntohs (mh->type),
                (unsigned int) ntohs (mh->size));
    finish_cmc_handling (cmc);*/
    /* @a cmc lives on in the ring buffer; #send_cmc_ack() and
       #resume_cmc_client() have recorded that they ran, so replaying it
       from #send_msg_from_cache() cannot ACK or continue a second time. */
    finish_cmc_handling_with_continue (cmc, GNUNET_NO);
    return;
  }
  finish_handling_raw_message (vl, mh, cmc, GNUNET_YES);
}

References RingBufferEntry::cmc, VirtualLink::confirmed, finish_cmc_handling(), finish_cmc_handling_with_continue(), finish_handling_raw_message(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GST_stats, 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, 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

cls	a struct CommunicatorMessageContext
fb	the send message that was sent

Returns

GNUNET_YES if message is well-formed

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

{
  uint16_t size = ntohs (fb->header.size);
  uint16_t bsize = size - sizeof(*fb);
 
  (void) cls;
  if (0 == bsize)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (bsize + ntohs (fb->frag_off) > ntohs (fb->msg_size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (ntohs (fb->frag_off) >= ntohs (fb->msg_size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_YES;
}

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

cls	a struct AcknowledgementCummulator *

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

{
  struct AcknowledgementCummulator *ac = cls;
 
  ac->task = NULL;
  GNUNET_assert (0 == ac->num_acks);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (ack_cummulators, &ac->target, ac));
  GNUNET_free (ac);
}

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

cls	a struct AcknowledgementCummulator *

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

{
  struct Neighbour *n;
  struct VirtualLink *vl;
  struct AcknowledgementCummulator *ac = cls;
  char buf[sizeof(struct TransportReliabilityAckMessage)
           + ac->num_acks
           * sizeof(struct TransportCummulativeAckPayloadP)] GNUNET_ALIGN;
  struct TransportReliabilityAckMessage *ack =
    (struct TransportReliabilityAckMessage *) buf;
  struct TransportCummulativeAckPayloadP *ap;
 
  ac->task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending ACK with %u components to %s\n",
              ac->num_acks,
              GNUNET_i2s (&ac->target));
  GNUNET_assert (0 < ac->num_acks);
  ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK);
  ack->header.size =
    htons (sizeof(*ack)
           + ac->num_acks * sizeof(struct TransportCummulativeAckPayloadP));
  ack->ack_counter = htonl (ac->ack_counter += ac->num_acks);
  ap = (struct TransportCummulativeAckPayloadP *) &ack[1];
  for (unsigned int i = 0; i < ac->num_acks; i++)
  {
    ap[i].ack_uuid = ac->ack_uuids[i].ack_uuid;
    ap[i].ack_delay = GNUNET_TIME_relative_hton (
      GNUNET_TIME_absolute_get_duration (ac->ack_uuids[i].receive_time));
  }
  /*route_control_message_without_fc (
    &ac->target,
    &ack->header,
    RMO_DV_ALLOWED);*/
  vl = lookup_virtual_link (&ac->target);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    route_control_message_without_fc (
      vl,
      &ack->header,
      RMO_DV_ALLOWED);
  }
  else
  {
    /* Use route via neighbour */
    n = lookup_neighbour (&ac->target);
    if (NULL != n)
      route_via_neighbour (
        n,
        &ack->header,
        RMO_NONE);
  }
  ac->num_acks = 0;
  /* The deadline belonged to the batch we just sent.  #cummulative_ack()
     only ever lowers it (GNUNET_TIME_absolute_min), so leaving it behind
     means every later ACK is armed with GNUNET_SCHEDULER_add_at() on a time
     that has already passed: the task fires on the next scheduler pass and
     the batching this whole structure exists for is gone for good -- one
     ACK message per received message, for the rest of the process' life. */
  ac->min_transmission_time = GNUNET_TIME_UNIT_FOREVER_ABS;
  ac->task = GNUNET_SCHEDULER_add_delayed (ACK_CUMMULATOR_TIMEOUT,
                                           &destroy_ack_cummulator,
                                           ac);
}

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_TIME_UNIT_FOREVER_ABS, GNUNET_YES, TransportReliabilityAckMessage::header, lookup_neighbour(), lookup_virtual_link(), AcknowledgementCummulator::min_transmission_time, 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

pid	target peer
ack_uuid	UUID to ack
max_delay	how long can the ACK wait

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

{
  struct AcknowledgementCummulator *ac;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Scheduling ACK %s for transmission to %s\n",
              GNUNET_uuid2s (&ack_uuid->value),
              GNUNET_i2s (pid));
  ac = GNUNET_CONTAINER_multipeermap_get (ack_cummulators, pid);
  if (NULL == ac)
  {
    ac = GNUNET_new (struct AcknowledgementCummulator);
    ac->target = *pid;
    ac->min_transmission_time = max_delay;
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_put (
                     ack_cummulators,
                     &ac->target,
                     ac,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  else
  {
    if (MAX_CUMMULATIVE_ACKS == ac->num_acks)
    {
      /* Must run immediately, ack buffer full.  Cancel the pending task
         FIRST: #transmit_cummulative_ack_cb() clears @e task without
         cancelling it, which would leave the old task armed with its
         handle lost. */
      GNUNET_SCHEDULER_cancel (ac->task);
      ac->task = NULL;
      transmit_cummulative_ack_cb (ac);
    }
    GNUNET_SCHEDULER_cancel (ac->task);
    ac->min_transmission_time =
      GNUNET_TIME_absolute_min (ac->min_transmission_time, max_delay);
  }
  GNUNET_assert (ac->num_acks < MAX_CUMMULATIVE_ACKS);
  ac->ack_uuids[ac->num_acks].receive_time = GNUNET_TIME_absolute_get ();
  ac->ack_uuids[ac->num_acks].ack_uuid = *ack_uuid;
  ac->num_acks++;
  ac->task = GNUNET_SCHEDULER_add_at (ac->min_transmission_time,
                                      &transmit_cummulative_ack_cb,
                                      ac);
}

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, 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

cls	a struct FindByMessageUuidContext
key	a key (unused)
value	a struct ReassemblyContext

Returns

GNUNET_YES if not found, GNUNET_NO if found

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

{
  struct FindByMessageUuidContext *fc = cls;
  struct ReassemblyContext *rc = value;
 
  (void) key;
  if (0 == GNUNET_memcmp (&fc->message_uuid, &rc->msg_uuid))
  {
    fc->rc = rc;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
fb	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  struct VirtualLink *vl;
  struct ReassemblyContext *rc;
  const struct GNUNET_MessageHeader *msg;
  uint16_t msize;
  uint16_t fsize;
  uint16_t frag_off;
  char *target;
  struct GNUNET_TIME_Relative cdelay;
  struct FindByMessageUuidContext fc;
 
  vl = lookup_virtual_link (&cmc->im.sender);
  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
  {
    /* Entirely normal: fragments of a message that was already in flight
       keep arriving for a while after a link goes down, and a peer that has
       validated us may start sending before we have validated it.  This used
       to call #GNUNET_SERVICE_client_drop(), which disconnects the
       communicator *process* -- every queue it owns, hence every neighbour
       reachable through it, hence every CORE session.  On a peer with many
       neighbours a single ill-timed fragment therefore dropped all
       connections at once, and since the fragment comes from the network,
       any peer could cause it at will.  Drop the fragment, keep the
       communicator; see #demultiplex_with_cmc() for the same reasoning. */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No virtual link for %s to handle fragment\n",
                GNUNET_i2s (&cmc->im.sender));
    GNUNET_STATISTICS_update (GST_stats,
                              "# fragments dropped (virtual link down)",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  if (NULL == vl->reassembly_map)
  {
    vl->reassembly_map = GNUNET_CONTAINER_multihashmap32_create (8);
    vl->reassembly_heap =
      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
    vl->reassembly_timeout_task =
      GNUNET_SCHEDULER_add_delayed (REASSEMBLY_EXPIRATION,
                                    &reassembly_cleanup_task,
                                    vl);
  }
  msize = ntohs (fb->msg_size);
  fc.message_uuid = fb->msg_uuid;
  fc.rc = NULL;
  (void) GNUNET_CONTAINER_multihashmap32_get_multiple (vl->reassembly_map,
                                                       fb->msg_uuid.uuid,
                                                       &find_by_message_uuid,
                                                       &fc);
  fsize = ntohs (fb->header.size) - sizeof(*fb);
  if (NULL == (rc = fc.rc))
  {
    /* Bound the RAM a single sender can pin here: @e msg_size is chosen by
       the peer, not by us. */
    while (GNUNET_CONTAINER_multihashmap32_size (vl->reassembly_map) >=
           MAX_REASSEMBLY_CONTEXTS)
    {
      struct ReassemblyContext *drop;
 
      drop = GNUNET_CONTAINER_heap_peek (vl->reassembly_heap);
      GNUNET_assert (NULL != drop);
      GNUNET_STATISTICS_update (GST_stats,
                                "# Reassembly contexts dropped (limit reached)",
                                1,
                                GNUNET_NO);
      free_reassembly_context (drop);
    }
    rc = GNUNET_malloc (sizeof(*rc) + msize    /* reassembly payload buffer */
                        + (msize + 7) / 8 * sizeof(uint8_t) /* bitfield */);
    rc->msg_uuid = fb->msg_uuid;
    rc->virtual_link = vl;
    rc->msg_size = msize;
    rc->reassembly_timeout =
      GNUNET_TIME_relative_to_absolute (REASSEMBLY_EXPIRATION);
    rc->last_frag = GNUNET_TIME_absolute_get ();
    rc->hn = GNUNET_CONTAINER_heap_insert (vl->reassembly_heap,
                                           rc,
                                           rc->reassembly_timeout.abs_value_us);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multihashmap32_put (
                     vl->reassembly_map,
                     rc->msg_uuid.uuid,
                     rc,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
    target = (char *) &rc[1];
    rc->bitfield = (uint8_t *) (target + rc->msg_size);
    /* The bitfield loop below decrements @e msg_missing once per newly
       received byte, so this must always start at the full message size:
       initialising it to 0 for a single-fragment message made it
       underflow, and the message was then never delivered. */
    rc->msg_missing = rc->msg_size;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received fragment with size %u at offset %u/%u %u bytes missing from %s for NEW message %"
                PRIu64 "\n",
                fsize,
                ntohs (fb->frag_off),
                msize,
                rc->msg_missing,
                GNUNET_i2s (&cmc->im.sender),
                fb->msg_uuid.uuid);
  }
  else
  {
    target = (char *) &rc[1];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received fragment at offset %u/%u from %s for message %u\n",
                ntohs (fb->frag_off),
                msize,
                GNUNET_i2s (&cmc->im.sender),
                (unsigned int) fb->msg_uuid.uuid);
  }
  if (msize != rc->msg_size)
  {
    GNUNET_break (0);
    finish_cmc_handling (cmc);
    return;
  }
 
  /* reassemble */
  if (0 == fsize)
  {
    GNUNET_break (0);
    finish_cmc_handling (cmc);
    return;
  }
  frag_off = ntohs (fb->frag_off);
  if (frag_off + fsize > msize)
  {
    /* Fragment (plus fragment size) exceeds message size! */
    GNUNET_break_op (0);
    finish_cmc_handling (cmc);
    return;
  }
  memcpy (&target[frag_off], &fb[1], fsize);
  /* update bitfield and msg_missing */
  for (unsigned int i = frag_off; i < frag_off + fsize; i++)
  {
    if (0 == (rc->bitfield[i / 8] & (1 << (i % 8))))
    {
      rc->bitfield[i / 8] |= (1 << (i % 8));
      rc->msg_missing--;
    }
  }
 
  /* Compute cumulative ACK */
  cdelay = GNUNET_TIME_absolute_get_duration (rc->last_frag);
  cdelay = GNUNET_TIME_relative_multiply (cdelay, rc->msg_missing / fsize);
  if (0 == rc->msg_missing)
    cdelay = GNUNET_TIME_UNIT_ZERO;
  cummulative_ack (&cmc->im.sender,
                   &fb->ack_uuid,
                   GNUNET_TIME_relative_to_absolute (cdelay));
  rc->last_frag = GNUNET_TIME_absolute_get ();
  /* is reassembly complete? */
  if (0 != rc->msg_missing)
  {
    finish_cmc_handling (cmc);
    return;
  }
  /* reassembly is complete, verify result */
  msg = (const struct GNUNET_MessageHeader *) &rc[1];
  if (ntohs (msg->size) != rc->msg_size)
  {
    GNUNET_break (0);
    free_reassembly_context (rc);
    finish_cmc_handling (cmc);
    return;
  }
  /* successful reassembly */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Fragment reassembly complete for message %u\n",
              (unsigned int) fb->msg_uuid.uuid);
  /* FIXME: check that the resulting msg is NOT a
     DV Box or Reliability Box, as that is NOT allowed! */
  {
    uint16_t rsize = rc->msg_size;
    char rbuf[rsize] GNUNET_ALIGN;
 
    /* Copy the reassembled message out and release `rc' BEFORE
       demultiplexing: the inner message may tear down the virtual link,
       which frees every reassembly context of that link -- the old code
       then used and freed `rc' a second time afterwards. */
    memcpy (rbuf, msg, rsize);
    free_reassembly_context (rc);
    cmc->mh = (const struct GNUNET_MessageHeader *) rbuf;
    demultiplex_with_cmc (cmc);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, TransportFragmentBoxMessage::ack_uuid, ReassemblyContext::bitfield, VirtualLink::confirmed, cummulative_ack(), demultiplex_with_cmc(), find_by_message_uuid(), finish_cmc_handling(), TransportFragmentBoxMessage::frag_off, free_reassembly_context(), GNUNET_ALIGN, GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_ZERO, GST_stats, TransportFragmentBoxMessage::header, ReassemblyContext::hn, CommunicatorMessageContext::im, ReassemblyContext::last_frag, lookup_virtual_link(), MAX_REASSEMBLY_CONTEXTS, 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, 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

cls	a struct CommunicatorMessageContext
rb	the send message that was sent

Returns

GNUNET_YES if message is well-formed

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

{
  const struct GNUNET_MessageHeader *box =  (const struct
                                             GNUNET_MessageHeader *) &rb[1];
  (void) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "check_send_msg with size %u: inner msg type %u and size %u (%lu %lu)\n",
              ntohs (rb->header.size),
              ntohs (box->type),
              ntohs (box->size),
              sizeof (struct TransportReliabilityBoxMessage),
              sizeof (struct GNUNET_MessageHeader));
  GNUNET_MQ_check_boxed_message (rb);
  return GNUNET_YES;
}

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
rb	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &rb[1];
  struct GNUNET_TIME_Relative rtt;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received reliability box from %s with UUID %s of type %u\n",
              GNUNET_i2s (&cmc->im.sender),
              GNUNET_uuid2s (&rb->ack_uuid.value),
              (unsigned int) ntohs (inbox->type));
  rtt = GNUNET_TIME_UNIT_SECONDS; /* FIXME: should base this on "RTT", but we
                                     do not really have an RTT for the
                                   * incoming* queue (should we have
                                     the sender add it to the rb message?) */
  cummulative_ack (
    &cmc->im.sender,
    &rb->ack_uuid,
    (0 == ntohl (rb->ack_countdown))
    ? GNUNET_TIME_UNIT_ZERO_ABS
    : GNUNET_TIME_relative_to_absolute (
      GNUNET_TIME_relative_divide (rtt, 8 /* FIXME: magic constant */)));
  /* continue with inner message */
  /* FIXME: check that inbox is NOT a DV Box, fragment or another
     reliability box (not allowed!) */
  cmc->mh = inbox;
  demultiplex_with_cmc (cmc);
}

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]	pd	data to update
	age	current age

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

{
  unsigned int sage;
 
  if (age == pd->last_age)
    return; /* nothing to do */
  sage = GNUNET_MAX (pd->last_age, age - 2 * GOODPUT_AGING_SLOTS);
  for (unsigned int i = sage; i <= age - GOODPUT_AGING_SLOTS; i++)
  {
    struct TransmissionHistoryEntry *the = &pd->the[i % GOODPUT_AGING_SLOTS];
 
    the->bytes_sent = 0;
    the->bytes_received = 0;
  }
  pd->last_age = age;
}

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]	pd	data to update
	rtt	latest round-trip time
	bytes_transmitted_ok	number of bytes receiver confirmed as received

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

{
  uint64_t nval = rtt.rel_value_us;
  uint64_t oval = pd->aged_rtt.rel_value_us;
  unsigned int age = get_age ();
  struct TransmissionHistoryEntry *the = &pd->the[age % GOODPUT_AGING_SLOTS];
 
  if (oval == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
    pd->aged_rtt = rtt;
  else
    pd->aged_rtt.rel_value_us = (nval + 7 * oval) / 8;
  update_pd_age (pd, age);
  the->bytes_received += bytes_transmitted_ok;
}

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

q	queue to update
rtt	round trip time observed
bytes_transmitted_ok	number of bytes successfully transmitted

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

{
  update_performance_data (&q->pd, rtt, bytes_transmitted_ok);
}

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

dvh	distance vector path data to update
rtt	round trip time observed
bytes_transmitted_ok	number of bytes successfully transmitted

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

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

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

pm	pending message that was transmitted

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

{
  struct PendingMessage *pos;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Complete transmission of message %" PRIu64 " %u\n",
              pm->logging_uuid,
              pm->pmt);
  switch (pm->pmt)
  {
  case PMT_CORE:
  case PMT_RELIABILITY_BOX:
    /* Full message sent, we are done */
    client_send_response (pm);
    return;
 
  case PMT_FRAGMENT_BOX:
    /* Fragment sent over reliable channel */
    pos = pm->frag_parent;
    GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm);
    free_pending_message (pm);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "pos frag_off %lu pos bytes_msg %lu pmt %u parent %u\n",
                (unsigned long) pos->frag_off,
                (unsigned long) pos->bytes_msg,
                pos->pmt,
                NULL == pos->frag_parent ? 1 : 0);
    /* check if subtree is done */
    while ((NULL == pos->head_frag) && (pos->frag_off == (pos->bytes_msg
                                                          - sizeof(struct
                                                                   TransportFragmentBoxMessage)))
           &&
           (NULL != pos->frag_parent))
    {
      pm = pos;
      pos = pm->frag_parent;
      if ((NULL == pos) && (PMT_DV_BOX == pm->pmt))
      {
        client_send_response (pm);
        return;
      }
      else if (PMT_DV_BOX == pm->pmt)
      {
        client_send_response (pos);
        return;
      }
      GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm);
      free_pending_message (pm);
    }
 
    /* Was this the last applicable fragment?
 
       NOTE: @a pos may be a DV box here, and then it is NOT the message the
       client is waiting for -- its @e frag_parent is, and that parent's
       @e bpm points at @a pos.  Answering the client directly (and thereby
       releasing @a pos through #free_pending_message()) left @e bpm of a
       message that is still queued pointing at freed memory, which
       #transmit_on_queue() reads and may free a second time.  Hand it to
       ourselves instead: the #PMT_DV_BOX case below clears @e bpm and
       answers for the parent, and for every other @e pmt it does exactly
       what the direct call did. */
    if ((NULL == pos->head_frag) && (NULL == pos->frag_parent || PMT_DV_BOX ==
                                     pos->pmt) &&
        (pos->frag_off == pos->bytes_msg))
      completed_pending_message (pos);
    return;
 
  case PMT_DV_BOX:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Completed transmission of message %" PRIu64 " (DV Box)\n",
                pm->logging_uuid);
    if (NULL != pm->frag_parent)
    {
      pos = pm->frag_parent;
      free_pending_message (pm);
      pos->bpm = NULL;
      client_send_response (pos);
    }
    else
      client_send_response (pm);
    return;
  }
}

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

Referenced by completed_pending_message(), 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

pa	the pending acknowledgement that was satisfied
ack_delay	artificial delay from cumulative acks created by the other peer

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

{
  struct GNUNET_TIME_Relative delay;
  struct PendingMessage *pm = pa->pm;
 
  delay = GNUNET_TIME_absolute_get_duration (pa->transmission_time);
  delay = GNUNET_TIME_relative_subtract (delay, ack_delay);
  if (NULL != pa->queue && 1 == pa->num_send)
    update_queue_performance (pa->queue, delay, pa->message_size);
  if (NULL != pa->dvh && 1 == pa->num_send)
    update_dvh_performance (pa->dvh, delay, pa->message_size);
  /* Retire @a pa BEFORE handing its message on.  completed_pending_message()
     ends in free_pending_message() for anything it finishes, and that now
     releases every acknowledgement still attached to the message -- this one
     included.  Freeing it afterwards is a double free, and it aborts on the
     GNUNET_assert() over multiuuidmap_remove() in
     free_pending_acknowledgement(), the map entry having gone with the first
     release.  Nothing below needs @a pa, only its message. */
  free_pending_acknowledgement (pa);
  if (NULL != pm)
    completed_pending_message (pm);
}

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

cls	a struct CommunicatorMessageContext (unused)
ra	the message that was received

Returns

#GNUNET_Ok if ra is well-formed

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

{
  unsigned int n_acks;
 
  (void) cls;
  n_acks = (ntohs (ra->header.size) - sizeof(*ra))
           / sizeof(struct TransportCummulativeAckPayloadP);
  if (0 == n_acks)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((ntohs (ra->header.size) - sizeof(*ra)) !=
      n_acks * sizeof(struct TransportCummulativeAckPayloadP))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
ra	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  const struct TransportCummulativeAckPayloadP *ack;
  unsigned int n_acks;
  uint32_t ack_counter;
 
  n_acks = (ntohs (ra->header.size) - sizeof(*ra))
           / sizeof(struct TransportCummulativeAckPayloadP);
  ack = (const struct TransportCummulativeAckPayloadP *) &ra[1];
  for (unsigned int i = 0; i < n_acks; i++)
  {
    struct PendingAcknowledgement *pa =
      GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value);
    if (NULL == pa)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Received ACK from %s with UUID %s which is unknown to us!\n",
                  GNUNET_i2s (&cmc->im.sender),
                  GNUNET_uuid2s (&ack[i].ack_uuid.value));
      GNUNET_STATISTICS_update (
        GST_stats,
        "# FRAGMENT_ACKS dropped, no matching pending message",
        1,
        GNUNET_NO);
      continue;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received ACK from %s with UUID %s\n",
                GNUNET_i2s (&cmc->im.sender),
                GNUNET_uuid2s (&ack[i].ack_uuid.value));
    handle_acknowledged (pa, GNUNET_TIME_relative_ntoh (ack[i].ack_delay));
  }
 
  ack_counter = ntohl (ra->ack_counter);
  (void) ack_counter;  /* silence compiler warning for now */
  // FIXME-OPTIMIZE: track ACK losses based on ack_counter somewhere!
  // (DV and/or Neighbour?)
  finish_cmc_handling (cmc);
}

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

cls	a struct CommunicatorMessageContext
be	the send message that was sent

Returns

GNUNET_YES if message is well-formed

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

{
  uint16_t size = ntohs (be->header.size) - sizeof(*be);
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &be[1];
  const char *is;
  uint16_t isize;
 
  (void) cls;
  /* MUST bound the buffer before reading @a inbox: the size check below
     dereferences it, and a message consisting of nothing but the header
     leaves no bytes to read. */
  if (size <= sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (ntohs (inbox->size) >= size)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  isize = ntohs (inbox->size);
  is = ((const char *) inbox) + isize;
  size -= isize;
  if ('\0' != is[size - 1])
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_YES;
}

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
be	the message that was received

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

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct CommunicatorMessageContext *cmc = cls;
  struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *cbi;
  struct GNUNET_MQ_Envelope *env;
  struct TransportClient *tc;
  const struct GNUNET_MessageHeader *inbox =
    (const struct GNUNET_MessageHeader *) &be[1];
  uint16_t isize = ntohs (inbox->size);
  const char *target_communicator = ((const char *) inbox) + isize;
  char *sender;
  char *self;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  GNUNET_asprintf (&sender,
                   "%s",
                   GNUNET_i2s (&cmc->im.sender));
  GNUNET_asprintf (&self,
                   "%s",
                   GNUNET_i2s (my_identity));
 
  /* Find client providing this communicator */
  for (tc = clients_head; NULL != tc; tc = tc->next)
    if ((CT_COMMUNICATOR == tc->type) &&
        (NULL != tc->details.communicator.address_prefix) &&
        (0 ==
         strcmp (tc->details.communicator.address_prefix, target_communicator)))
      break;
  if (NULL == tc)
  {
    char *stastr;
 
    GNUNET_asprintf (
      &stastr,
      "# Backchannel message dropped: target communicator `%s' unknown",
      target_communicator);
    GNUNET_STATISTICS_update (GST_stats, stastr, 1, GNUNET_NO);
    GNUNET_free (stastr);
    GNUNET_free (sender);
    GNUNET_free (self);
    finish_cmc_handling (cmc);
    return;
  }
  /* Finally, deliver backchannel message to communicator */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Delivering backchannel message from %s to %s of type %u to %s\n",
              sender,
              self,
              ntohs (inbox->type),
              target_communicator);
  env = GNUNET_MQ_msg_extra (
    cbi,
    isize,
    GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING);
  cbi->pid = cmc->im.sender;
  memcpy (&cbi[1], inbox, isize);
  GNUNET_MQ_send (tc->mq, env);
  GNUNET_free (sender);
  GNUNET_free (self);
  finish_cmc_handling (cmc);
}

References clients_head, CT_COMMUNICATOR, env, finish_cmc_handling(), GNUNET_asprintf(), GNUNET_assert, 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_PILS_get_identity(), GNUNET_STATISTICS_update(), GST_stats, CommunicatorMessageContext::im, my_identity, GNUNET_TRANSPORT_CommunicatorBackchannelIncoming::pid, pils, 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

cls	a struct DistanceVector

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

{
  struct DistanceVector *dv = cls;
  struct DistanceVectorHop *pos;
  struct GNUNET_TIME_Absolute next;
 
  dv->timeout_task = NULL;
  /* @e dv_head is NOT sorted by @e timeout: learn_dv_path() inserts a new
     hop at the head, and moves a rediscovered one back to the head, so the
     list runs newest (i.e. latest deadline) first.  Stopping at the first
     live entry therefore inspected exactly the youngest hop and re-armed
     for *its* deadline, which is the last one of the whole set: expired
     hops behind it were never collected, and check_vl_transmission() kept
     skipping them one by one for as long as the route lived.  Sweep all of
     them and come back for the earliest survivor. */
  next = GNUNET_TIME_UNIT_FOREVER_ABS;
  pos = dv->dv_head;
  while (NULL != pos)
  {
    struct DistanceVectorHop *next_pos = pos->next_dv;
 
    GNUNET_assert (dv == pos->dv);
    if (0 == GNUNET_TIME_absolute_get_remaining (pos->timeout).rel_value_us)
      free_distance_vector_hop (pos);
    else
      next = GNUNET_TIME_absolute_min (next, pos->timeout);
    pos = next_pos;
  }
  if (NULL == dv->dv_head)
  {
    free_dv_route (dv);
    return;
  }
  dv->timeout_task =
    GNUNET_SCHEDULER_add_at (next, &path_cleanup_cb, dv);
}

References DistanceVectorHop::dv, DistanceVector::dv_head, free_distance_vector_hop(), free_dv_route(), GNUNET_assert, GNUNET_SCHEDULER_add_at(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_min(), GNUNET_TIME_UNIT_FOREVER_ABS, DistanceVectorHop::next_dv, 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 8559 of file gnunet-service-transport.c.

{
 
  const struct GNUNET_PeerIdentity target = vl->target;
 
 
  if ((GNUNET_YES == is_ring_buffer_full) || (0 < ring_buffer_head))
  {
    struct RingBufferEntry *ring_buffer_copy[RING_BUFFER_SIZE];
    unsigned int tail = GNUNET_YES == is_ring_buffer_full ? ring_buffer_head :
                        0;
    unsigned int head = GNUNET_YES == is_ring_buffer_full ? RING_BUFFER_SIZE :
                        ring_buffer_head;
    struct GNUNET_TRANSPORT_IncomingMessage im;
    struct CommunicatorMessageContext *cmc;
    struct RingBufferEntry *rbe;
    struct GNUNET_MessageHeader *mh;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending from ring buffer, which has %u items\n",
                head);
 
    ring_buffer_head = 0;
    for (unsigned int i = 0; i < head; i++)
    {
      rbe = ring_buffer[(i + tail) % RING_BUFFER_SIZE];
      cmc = rbe->cmc;
      mh = rbe->mh;
 
      im = cmc->im;
      // mh = cmc->mh;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending message of type %u to ring buffer target %s using vl target %s index %u\n",
                  mh->type,
                  GNUNET_i2s (&im.sender),
                  GNUNET_i2s2 (&target),
                  (i + tail) % RING_BUFFER_SIZE);
      if (0 == GNUNET_memcmp (&target, &im.sender))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Finish handling message of type %u and size %u\n",
                    (unsigned int) ntohs (mh->type),
                    (unsigned int) ntohs (mh->size));
        finish_handling_raw_message (vl, mh, cmc, GNUNET_NO);
        GNUNET_free (mh);
        GNUNET_free (rbe->cmc);
        GNUNET_free (rbe);
      }
      else
      {
        ring_buffer_copy[ring_buffer_head] = rbe;
        ring_buffer_head++;
      }
    }
 
    if ((GNUNET_YES == is_ring_buffer_full) &&
        (RING_BUFFER_SIZE > ring_buffer_head))
    {
      is_ring_buffer_full = GNUNET_NO;
    }
 
    for (unsigned int i = 0; i < ring_buffer_head; i++)
    {
      ring_buffer[i] = ring_buffer_copy[i];
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "ring_buffer[i]->mh->type for i %u %u\n",
                  i,
                  ring_buffer[i]->mh->type);
    }
    /* MUST clear the consumed slots, we freed those entries above */
    for (unsigned int i = ring_buffer_head; i < RING_BUFFER_SIZE; i++)
      ring_buffer[i] = NULL;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u items still in ring buffer\n",
                ring_buffer_head);
    /* If we consumed nothing, compaction rewrote the buffer in place and
       left the write index one past the end.  #handle_raw_message() would
       then read ring_buffer[RING_BUFFER_SIZE] and free whatever that is.
       The buffer is still full, and compaction moved the oldest entry to
       slot 0, so that is where the next write belongs. */
    if (RING_BUFFER_SIZE == ring_buffer_head)
      ring_buffer_head = 0;
  }
 
  if ((GNUNET_YES == is_ring_buffer_dv_full) || (0 < ring_buffer_dv_head))
  {
    struct PendingMessage *ring_buffer_dv_copy[RING_BUFFER_SIZE];
    struct PendingMessage *pm;
    unsigned int tail = GNUNET_YES == is_ring_buffer_dv_full ?
                        ring_buffer_dv_head :
                        0;
    unsigned int head = GNUNET_YES == is_ring_buffer_dv_full ?
                        RING_BUFFER_SIZE :
                        ring_buffer_dv_head;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending from ring buffer dv, which has %u items\n",
                head);
 
    ring_buffer_dv_head = 0;
    for (unsigned int i = 0; i < head; i++)
    {
      pm = ring_buffer_dv[(i + tail) % RING_BUFFER_SIZE];
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Sending to ring buffer target %s using vl target %s\n",
                  GNUNET_i2s (&pm->target),
                  GNUNET_i2s2 (&target));
      if (0 == GNUNET_memcmp (&target, &pm->target))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Adding PendingMessage to vl, checking transmission.\n");
        pm->vl = vl;
        GNUNET_CONTAINER_MDLL_insert (vl,
                                      vl->pending_msg_head,
                                      vl->pending_msg_tail,
                                      pm);
 
        check_vl_transmission (vl);
      }
      else
      {
        ring_buffer_dv_copy[ring_buffer_dv_head] = pm;
        ring_buffer_dv_head++;
      }
    }
 
    if (is_ring_buffer_dv_full && (RING_BUFFER_SIZE > ring_buffer_dv_head))
    {
      is_ring_buffer_dv_full = GNUNET_NO;
    }
 
    for (unsigned int i = 0; i < ring_buffer_dv_head; i++)
      ring_buffer_dv[i] = ring_buffer_dv_copy[i];
    /* MUST clear the consumed slots: entries we handed to a VirtualLink are
       now owned by that link, and #forward_dv_box() would GNUNET_free() them
       again once the ring buffer wraps around. */
    for (unsigned int i = ring_buffer_dv_head; i < RING_BUFFER_SIZE; i++)
      ring_buffer_dv[i] = NULL;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "%u items still in ring buffer dv.\n",
                ring_buffer_dv_head);
    /* Same one-past-the-end hazard as above: #forward_dv_box() reads
       ring_buffer_dv[ring_buffer_dv_head] and GNUNET_free()s it. */
    if (RING_BUFFER_SIZE == ring_buffer_dv_head)
      ring_buffer_dv_head = 0;
  }
}

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, 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

hop	a path to some peer that is the reason for activation

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

{
  struct DistanceVector *dv = hop->dv;
  struct VirtualLink *vl;
 
  vl = lookup_virtual_link (&dv->target);
  if (NULL == vl)
  {
 
    vl = GNUNET_new (struct VirtualLink);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Creating new virtual link %p to %s using DV!\n",
                vl,
                GNUNET_i2s (&dv->target));
    vl->burst_addr = NULL;
    vl->confirmed = GNUNET_YES;
    vl->message_uuid_ctr =
      GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    vl->target = dv->target;
    vl->core_recv_window = RECV_WINDOW_SIZE;
    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
    /* What the peer will grant us in its very first FLOW_CONTROL anyway
       (@e incoming_fc_window_size plus what we have sent, i.e. nothing).
       Starting at zero instead means a link that is up, validated and
       working carries nothing at all until an FC round trip completes --
       and if the peer cannot answer, not ever. */
    vl->outbound_fc_window_size = DEFAULT_WINDOW_SIZE;
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_put (
                    links,
                    &vl->target,
                    vl,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    vl->dv = dv;
    dv->vl = vl;
    vl->visibility_task =
      GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl);
    consider_sending_fc (vl);
    /* We lacked a confirmed connection to the target
       before, so tell CORE about it (finally!) */
    cores_send_connect_info (&dv->target);
    send_msg_from_cache (vl);
  }
  else
  {
    /* Link was already up, remember dv is also now available and we are done */
    vl->dv = dv;
    dv->vl = vl;
    if (GNUNET_NO == vl->confirmed)
    {
      vl->confirmed = GNUNET_YES;
      vl->visibility_task =
        GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl);
      consider_sending_fc (vl);
      /* We lacked a confirmed connection to the target
         before, so tell CORE about it (finally!) */
      cores_send_connect_info (&dv->target);
      send_msg_from_cache (vl);
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Virtual link to %s could now also use DV!\n",
                  GNUNET_i2s (&dv->target));
  }
}

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_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, VirtualLink::outbound_fc_window_size, 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

path	the 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_len	number of entries on the path, at least three!
network_latency	how long does the message take from us to path[path_len-1]? set to "forever" if unknown
path_valid_until	how 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 8813 of file gnunet-service-transport.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct DistanceVectorHop *hop;
  struct DistanceVector *dv;
  struct Neighbour *next_hop;
  unsigned int shorter_distance;
 
  if (path_len < 3)
  {
    /* what a boring path! not allowed! */
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  GNUNET_assert (0 == GNUNET_memcmp (my_identity, &path[0]));
  next_hop = lookup_neighbour (&path[1]);
  if (NULL == next_hop)
  {
    /* next hop must be a neighbour, otherwise this whole thing is useless! */
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  for (unsigned int i = 2; i < path_len; i++)
  {
    struct Neighbour *n = lookup_neighbour (&path[i]);
    struct GNUNET_TIME_Absolute q_timeout;
 
    if (NULL != n)
    {
      q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
      for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
        q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "remaining %lu to %s\n",
                  (unsigned long) GNUNET_TIME_absolute_get_remaining (q_timeout)
                  .rel_value_us,
                  GNUNET_i2s (&n->pid));
      if (0 != GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
      {
        /* Useless path: we have a direct active connection to some hop
           in the middle of the path, so this one is not even
           terribly useful for redundancy */
        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                    "Path of %u hops useless: directly link to hop %u (%s)\n",
                    path_len,
                    i,
                    GNUNET_i2s (&path[i]));
        GNUNET_STATISTICS_update (GST_stats,
                                  "# Useless DV path ignored: hop is neighbour",
                                  1,
                                  GNUNET_NO);
        return GNUNET_SYSERR;
      }
    }
  }
  dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &path[path_len - 1]);
  if (NULL == dv)
  {
    dv = GNUNET_new (struct DistanceVector);
    dv->target = path[path_len - 1];
    dv->timeout_task = GNUNET_SCHEDULER_add_delayed (DV_PATH_VALIDITY_TIMEOUT,
                                                     &path_cleanup_cb,
                                                     dv);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (
                     dv_routes,
                     &dv->target,
                     dv,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  /* Check if we have this path already! */
  shorter_distance = 0;
  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
       pos = pos->next_dv)
  {
    if (pos->distance < path_len - 3)
      shorter_distance++;
    /* Note that the distances in 'pos' excludes us (path[0]),
       the next_hop (path[1]) and the target so we need to subtract three
       and check next_hop explicitly */
    if ((pos->distance == path_len - 3) && (pos->next_hop == next_hop))
    {
      int match = GNUNET_YES;
 
      for (unsigned int i = 0; i < pos->distance; i++)
      {
        if (0 != GNUNET_memcmp (&pos->path[i], &path[i + 2]))
        {
          match = GNUNET_NO;
          break;
        }
      }
      if (GNUNET_YES == match)
      {
        struct GNUNET_TIME_Relative last_timeout;
 
        /* Re-discovered known path, update timeout */
        GNUNET_STATISTICS_update (GST_stats,
                                  "# Known DV path refreshed",
                                  1,
                                  GNUNET_NO);
        last_timeout = GNUNET_TIME_absolute_get_remaining (pos->timeout);
        pos->timeout =
          GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
        pos->path_valid_until =
          GNUNET_TIME_absolute_max (pos->path_valid_until, path_valid_until);
        GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, pos);
        GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, pos);
        if (0 <
            GNUNET_TIME_absolute_get_remaining (path_valid_until).rel_value_us)
          activate_core_visible_dv_path (pos);
        if (last_timeout.rel_value_us <
            GNUNET_TIME_relative_subtract (DV_PATH_VALIDITY_TIMEOUT,
                                           DV_PATH_DISCOVERY_FREQUENCY)
            .rel_value_us)
        {
          /* Some peer send DV learn messages too often, we are learning
             the same path faster than it would be useful; do not forward! */
          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                      "Rediscovered path too quickly, not forwarding further\n")
          ;
          return GNUNET_NO;
        }
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Refreshed known path to %s valid until %s, forwarding further\n",
                    GNUNET_i2s (&dv->target),
                    GNUNET_STRINGS_absolute_time_to_string (
                      pos->path_valid_until));
        return GNUNET_YES;
      }
    }
  }
  /* Count how many shorter paths we have (incl. direct
     neighbours) before simply giving up on this one! */
  if (shorter_distance >= MAX_DV_PATHS_TO_TARGET)
  {
    /* We have a shorter path already! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Have many shorter DV paths %s, not forwarding further\n",
                GNUNET_i2s (&dv->target));
    return GNUNET_NO;
  }
  /* create new DV path entry */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Discovered new DV path to %s valid until %s\n",
              GNUNET_i2s (&dv->target),
              GNUNET_STRINGS_absolute_time_to_string (path_valid_until));
  hop = GNUNET_malloc (sizeof(struct DistanceVectorHop)
                       + sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
  hop->next_hop = next_hop;
  hop->dv = dv;
  hop->path = (const struct GNUNET_PeerIdentity *) &hop[1];
  memcpy (&hop[1],
          &path[2],
          sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
  hop->timeout = GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
  hop->path_valid_until = path_valid_until;
  hop->distance = path_len - 3;
  hop->pd.aged_rtt = network_latency;
  GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, hop);
  GNUNET_CONTAINER_MDLL_insert (neighbour,
                                next_hop->dv_head,
                                next_hop->dv_tail,
                                hop);
  if (0 < GNUNET_TIME_absolute_get_remaining (path_valid_until).rel_value_us)
    activate_core_visible_dv_path (hop);
  return GNUNET_YES;
}

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_PILS_get_identity(), 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_stats, lookup_neighbour(), MAX_DV_PATHS_TO_TARGET, my_identity, DistanceVectorHop::next_hop, DistanceVectorHop::path, path_cleanup_cb(), DistanceVectorHop::path_valid_until, DistanceVectorHop::pd, Neighbour::pid, pils, 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

cls	a struct CommunicatorMessageContext
dvl	the send message that was sent

Returns

GNUNET_YES if message is well-formed

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

{
  const struct GNUNET_PeerIdentity *my_identity;
  uint16_t size = ntohs (dvl->header.size);
  uint16_t num_hops = ntohs (dvl->num_hops);
  const struct DVPathEntryP *hops = (const struct DVPathEntryP *) &dvl[1];
 
  (void) cls;
  if (size != sizeof(*dvl) + num_hops * sizeof(struct DVPathEntryP))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (num_hops > MAX_DV_HOPS_ALLOWED)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  for (unsigned int i = 0; i < num_hops; i++)
  {
    if (0 == GNUNET_memcmp (&dvl->initiator, &hops[i].hop))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if (0 == GNUNET_memcmp (my_identity, &hops[i].hop))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
  }
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_break_op, GNUNET_memcmp, GNUNET_PILS_get_identity(), GNUNET_SYSERR, GNUNET_YES, TransportDVLearnMessage::header, DVPathEntryP::hop, TransportDVLearnMessage::initiator, MAX_DV_HOPS_ALLOWED, my_identity, TransportDVLearnMessage::num_hops, pils, GNUNET_MessageHeader::size, and size.

Here is the call graph for this function:

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_hop	peer to send the message to
msg	message received
bi_history	bitmask specifying hops on path that were bidirectional
nhops	length of the hops array
hops	path the message traversed so far
in_time	when did we receive the message, used to calculate network delay

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

{
  struct DVPathEntryP *dhops;
  size_t fwd_size = sizeof(struct TransportDVLearnMessage)
                    + (nhops + 1) * sizeof(struct DVPathEntryP);
  /* Signing is synchronous and the routing calls below copy the message,
     so this never outlives the frame.  Keeping it on the stack matters:
     a hub forwards a DV learn to every eligible neighbour, so this is one
     of the hottest allocation sites in the service.  Size it by the hop
     limit rather than by @a nhops -- @a nhops is only asserted to be below
     that limit further down, and a VLA is sized before we get there. */
  char fwd_buf[sizeof(struct TransportDVLearnMessage)
               + (MAX_DV_HOPS_ALLOWED + 1)
               * sizeof(struct DVPathEntryP)] GNUNET_ALIGN;
  struct TransportDVLearnMessage *fwd
    = (struct TransportDVLearnMessage *) fwd_buf;
  struct GNUNET_TIME_Relative nnd;
  const struct GNUNET_PeerIdentity *my_identity;
  struct VirtualLink *vl;
  struct Neighbour *n;
 
  GNUNET_assert (nhops < MAX_DV_HOPS_ALLOWED);
  memset (fwd_buf, 0, fwd_size);
 
  /* compute message for forwarding */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding DV learn message originating from %s to %s\n",
              GNUNET_i2s (&msg->initiator),
              GNUNET_i2s2 (next_hop));
  GNUNET_assert (nhops < MAX_DV_HOPS_ALLOWED);
  fwd->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
  fwd->header.size = htons (sizeof(struct TransportDVLearnMessage)
                            + (nhops + 1) * sizeof(struct DVPathEntryP));
  fwd->num_hops = htons (nhops + 1);
  fwd->bidirectional = htons (bi_history);
  nnd = GNUNET_TIME_relative_add (GNUNET_TIME_absolute_get_duration (in_time),
                                  GNUNET_TIME_relative_ntoh (
                                    msg->non_network_delay));
  fwd->non_network_delay = GNUNET_TIME_relative_hton (nnd);
  fwd->init_sig = msg->init_sig;
  fwd->initiator = msg->initiator;
  fwd->challenge = msg->challenge;
  fwd->monotonic_time = msg->monotonic_time;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  dhops = (struct DVPathEntryP *) &fwd[1];
  GNUNET_memcpy (dhops, hops, sizeof(struct DVPathEntryP) * nhops);
  dhops[nhops].hop = *my_identity;
  {
    struct DvHopPS dhp = {
      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
      .purpose.size = htonl (sizeof(dhp)),
      .pred = (0 == nhops) ? msg->initiator : dhops[nhops - 1].hop,
      .succ = *next_hop,
      .challenge = msg->challenge
    };
 
    if (GNUNET_OK != sign_by_my_identity (&dhp.purpose,
                                          &dhops[nhops].hop_sig))
      return;   /* nobody would accept the path without our hop signature */
  }
  vl = lookup_virtual_link (next_hop);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    route_control_message_without_fc (vl,
                                      &fwd->header,
                                      RMO_UNCONFIRMED_ALLOWED);
    return;
  }
  /* Use route via neighbour */
  n = lookup_neighbour (next_hop);
  if (NULL != n)
    route_via_neighbour (n,
                         &fwd->header,
                         RMO_UNCONFIRMED_ALLOWED);
}

References TransportDVLearnMessage::bidirectional, TransportDVLearnMessage::challenge, VirtualLink::confirmed, GNUNET_ALIGN, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_i2s2(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN, GNUNET_OK, GNUNET_PILS_get_identity(), 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, TransportDVLearnMessage::header, DVPathEntryP::hop, DVPathEntryP::hop_sig, TransportDVLearnMessage::init_sig, TransportDVLearnMessage::initiator, lookup_neighbour(), lookup_virtual_link(), MAX_DV_HOPS_ALLOWED, TransportDVLearnMessage::monotonic_time, msg, my_identity, TransportDVLearnMessage::non_network_delay, TransportDVLearnMessage::num_hops, pils, GNUNET_CRYPTO_SignaturePurpose::purpose, DvHopPS::purpose, RMO_UNCONFIRMED_ALLOWED, route_control_message_without_fc(), route_via_neighbour(), sign_by_my_identity(), 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_time	monotonic time of the initiator
init	the signer
challenge	the challenge that was signed
init_sig	signature presumably by init

Returns

GNUNET_OK if the signature is valid

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

{
  struct DvInitPS ip = { .purpose.purpose = htonl (
                           GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
                         .purpose.size = htonl (sizeof(ip)),
                         .monotonic_time = sender_monotonic_time,
                         .challenge = *challenge };
 
  if (
    GNUNET_OK !=
    GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR,
                                &ip,
                                init_sig,
                                &init->public_key))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References DvInitPS::challenge, GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR, GNUNET_SYSERR, init, GNUNET_CRYPTO_SignaturePurpose::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

cls	a struct NeighbourSelectionContext *
pid	identity of the peer
value	a struct Neighbour

Returns

GNUNET_YES (always)

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

{
  struct NeighbourSelectionContext *nsc = cls;
 
  (void) value;
  if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
    return GNUNET_YES; /* skip initiator */
  for (unsigned int i = 0; i < nsc->nhops; i++)
    if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
      return GNUNET_YES;
  /* skip peers on path */
  nsc->num_eligible++;
  return GNUNET_YES;
}

References NeighbourSelectionContext::dvl, GNUNET_memcmp, GNUNET_YES, DVPathEntryP::hop, NeighbourSelectionContext::hops, TransportDVLearnMessage::initiator, NeighbourSelectionContext::nhops, NeighbourSelectionContext::num_eligible, 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

cls	a struct NeighbourSelectionContext *
pid	identity of the peer
value	a struct Neighbour

Returns

GNUNET_YES (always)

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

{
  struct NeighbourSelectionContext *nsc = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "transmission %s\n",
              GNUNET_i2s (pid));
  (void) value;
  if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
    return GNUNET_YES; /* skip initiator */
  for (unsigned int i = 0; i < nsc->nhops; i++)
    if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
      return GNUNET_YES;
  /* skip peers on path */
  for (unsigned int i = 0; i < nsc->num_selections; i++)
  {
    if (nsc->selections[i] == nsc->num_eligible)
    {
      forward_dv_learn (pid,
                        nsc->dvl,
                        nsc->bi_history,
                        nsc->nhops,
                        nsc->hops,
                        nsc->in_time);
      break;
    }
  }
  nsc->num_eligible++;
  return GNUNET_YES;
}

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, 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_taken	number of hops DVInit has travelled so far
neighbour_count	number of neighbours we have in total
eligible_count	number of neighbours we could in theory forward to

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

{
  double target_total = 50.0; /* FIXME: use LOG(NSE)? */
  double eligible_ratio =
    ((double) eligible_count) / ((double) neighbour_count);
  double boost_factor = eligible_ratio * eligible_ratio;
  unsigned int rnd;
  double left;
 
  if (hops_taken >= 64)
  {
    GNUNET_break (0);
    return 0;   /* precaution given bitshift below */
  }
  for (unsigned int i = 1; i < hops_taken; i++)
  {
    /* For each hop, subtract the expected number of targets
       reached at distance d (so what remains divided by 2^d) */
    target_total -= (target_total * boost_factor / (1LLU << i));
  }
  {
    double degree = target_total * boost_factor / (1LLU << hops_taken);
 
    rnd = (unsigned int) floor (degree);
    /* round up or down probabilistically depending on how close we were
       when floor()ing to rnd.  NOTE: this must be the fractional part of
       @e degree; using `target_total - rnd' here made the condition below
       true essentially always, so we always rounded up. */
    left = degree - (double) rnd;
  }
  if (UINT32_MAX * left >
      GNUNET_CRYPTO_random_u64 (UINT32_MAX))
    rnd++; /* round up */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Forwarding DV learn message of %u hops %u(/%u/%u) times\n",
              hops_taken,
              rnd,
              eligible_count,
              neighbour_count);
  return rnd;
}

References GNUNET_break, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

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

cls	a struct Neighbour
success	GNUNET_YES if peerstore was successful

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

{
  struct Neighbour *n = cls;
 
  n->sc = NULL;
  if (GNUNET_YES != success)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store other peer's monotonic time in peerstore!\n");
}

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

{
  struct GNUNET_TIME_Relative host_latency_sum;
  struct GNUNET_TIME_Relative latency;
  struct GNUNET_TIME_Relative network_latency;
  uint16_t nhops = ntohs (dvl->num_hops);;
 
  /* We initiated this, learn the forward path! */
  host_latency_sum = GNUNET_TIME_relative_ntoh (dvl->non_network_delay);
 
  // Need also something to lookup initiation time
  // to compute RTT! -> add RTT argument here?
  latency = GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh (
                                                 dvl->monotonic_time));
  /* @e non_network_delay is fully attacker-controlled, and our clock may
     simply be behind the initiator's: never assert on this. */
  if (latency.rel_value_us < host_latency_sum.rel_value_us)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV learn with implausible non-network delay",
                              1,
                              GNUNET_NO);
    return GNUNET_TIME_UNIT_FOREVER_REL;
  }
  // latency = GNUNET_TIME_UNIT_FOREVER_REL;   // FIXME: initialize properly
  // (based on dvl->challenge, we can identify time of origin!)
 
  network_latency = GNUNET_TIME_relative_subtract (latency, host_latency_sum);
  /* assumption: latency on all links is the same */
  network_latency = GNUNET_TIME_relative_divide (network_latency, nhops);
 
  return network_latency;
}

References GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_ntoh(), GNUNET_TIME_relative_subtract(), GNUNET_TIME_UNIT_FOREVER_REL, GST_stats, 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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
dvl	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc;
  int bi_hop;
  uint16_t nhops;
  uint16_t bi_history;
  const struct DVPathEntryP *hops;
  int do_fwd;
  int did_initiator;
  struct GNUNET_TIME_Absolute in_time;
  struct Neighbour *n;
  const struct GNUNET_PeerIdentity *my_identity;
 
  nhops = ntohs (dvl->num_hops);  /* 0 = sender is initiator */
  bi_history = ntohs (dvl->bidirectional);
  hops = (const struct DVPathEntryP *) &dvl[1];
  if (0 == nhops)
  {
    /* sanity check */
    if (0 != GNUNET_memcmp (&dvl->initiator, &cmc->im.sender))
    {
      GNUNET_break (0);
      finish_cmc_handling (cmc);
      return;
    }
    /* A zero-hop message we supposedly initiated ourselves would make the
       "we are the initiator" branch below read hops[0] and write past the
       end of its `path[nhops + 1]' array. */
    if (0 == GNUNET_memcmp (&dvl->initiator, GNUNET_PILS_get_identity (pils)))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "handle dv learn message last hop %s\n",
                GNUNET_i2s (&hops[nhops - 1].hop));
    /* sanity check */
    if (0 != GNUNET_memcmp (&hops[nhops - 1].hop, &cmc->im.sender))
    {
      GNUNET_break (0);
      finish_cmc_handling (cmc);
      return;
    }
  }
 
  GNUNET_assert (CT_COMMUNICATOR == cmc->tc->type);
  cc = cmc->tc->details.communicator.cc;
  bi_hop = (GNUNET_TRANSPORT_CC_RELIABLE ==
            cc); // FIXME: add bi-directional flag to cc?
  in_time = GNUNET_TIME_absolute_get ();
 
  /* continue communicator here, everything else can happen asynchronous! */
  finish_cmc_handling (cmc);
 
  n = lookup_neighbour (&dvl->initiator);
  if (NULL != n)
  {
    if ((n->dv_monotime_available == GNUNET_YES) &&
        (GNUNET_TIME_absolute_ntoh (dvl->monotonic_time).abs_value_us <
         n->last_dv_learn_monotime.abs_value_us))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV learn from %s discarded due to time travel",
                  GNUNET_i2s (&dvl->initiator));
      GNUNET_STATISTICS_update (GST_stats,
                                "# DV learn discarded due to time travel",
                                1,
                                GNUNET_NO);
      return;
    }
    if (GNUNET_OK != validate_dv_initiator_signature (dvl->monotonic_time,
                                                      &dvl->initiator,
                                                      &dvl->challenge,
                                                      &dvl->init_sig))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV learn signature from %s invalid\n",
                  GNUNET_i2s (&dvl->initiator));
      GNUNET_break_op (0);
      return;
    }
    n->last_dv_learn_monotime = GNUNET_TIME_absolute_ntoh (dvl->monotonic_time);
    if (GNUNET_YES == n->dv_monotime_available)
    {
      if (NULL != n->sc)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "store cancel\n");
        GNUNET_PEERSTORE_store_cancel (n->sc);
      }
      n->sc =
        GNUNET_PEERSTORE_store (peerstore,
                                "transport",
                                &dvl->initiator,
                                GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
                                &dvl->monotonic_time,
                                sizeof(dvl->monotonic_time),
                                GNUNET_TIME_UNIT_FOREVER_ABS,
                                GNUNET_PEERSTORE_STOREOPTION_REPLACE,
                                &neighbour_store_dvmono_cb,
                                n);
    }
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  /* OPTIMIZE-FIXME: asynchronously (!) verify signatures!,
     If signature verification load too high, implement random drop strategy */
  for (unsigned int i = 0; i < nhops; i++)
  {
    struct DvHopPS dhp = { .purpose.purpose =
                             htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
                           .purpose.size = htonl (sizeof(dhp)),
                           .pred = (0 == i) ? dvl->initiator : hops[i - 1].hop,
                           .succ = (nhops == i + 1) ? *my_identity
                                   : hops[i + 1].hop,
                           .challenge = dvl->challenge };
 
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP,
                                    &dhp,
                                    &hops[i].hop_sig,
                                    &hops[i].hop.public_key))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV learn from %s signature of hop %u invalid\n",
                  GNUNET_i2s (&dvl->initiator),
                  i);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "signature of hop %s invalid\n",
                  GNUNET_i2s (&hops[i].hop));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "pred %s\n",
                  GNUNET_i2s (&dhp.pred));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "succ %s\n",
                  GNUNET_i2s (&dhp.succ));
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "hash %s\n",
                  GNUNET_sh2s (&dhp.challenge.value));
      GNUNET_break_op (0);
      return;
    }
  }
  if (GNUNET_EXTRA_LOGGING > 0)
  {
    char *path;
 
    path = GNUNET_strdup (GNUNET_i2s (&dvl->initiator));
    for (unsigned int i = 0; i < nhops; i++)
    {
      char *tmp;
 
      GNUNET_asprintf (&tmp,
                       "%s%s%s",
                       path,
                       (bi_history & (1 << (nhops - i))) ? "<->" : "-->",
                       GNUNET_i2s (&hops[i].hop));
      GNUNET_free (path);
      path = tmp;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received DVInit via %s%s%s\n",
                path,
                bi_hop ? "<->" : "-->",
                GNUNET_i2s (my_identity));
    GNUNET_free (path);
  }
  do_fwd = GNUNET_YES;
  if (0 == GNUNET_memcmp (my_identity, &dvl->initiator))
  {
    struct GNUNET_PeerIdentity path[nhops + 1];
    struct GNUNET_TIME_Relative network_latency;
 
    /* We initiated this, learn the forward path! */
    path[0] = *my_identity;
    path[1] = hops[0].hop;
 
    network_latency = get_network_latency (dvl);
 
    for (unsigned int i = 2; i <= nhops; i++)
    {
      struct GNUNET_TIME_Relative ilat;
 
      /* assumption: linear latency increase per hop */
      ilat = GNUNET_TIME_relative_multiply (network_latency, i);
      path[i] = hops[i - 1].hop;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Learned path with %u hops to %s with latency %s\n",
                  i,
                  GNUNET_i2s (&path[i]),
                  GNUNET_STRINGS_relative_time_to_string (ilat, GNUNET_YES));
      learn_dv_path (path,
                     i + 1,
                     ilat,
                     GNUNET_TIME_relative_to_absolute (
                       ADDRESS_VALIDATION_LIFETIME));
    }
    /* as we initiated, do not forward again (would be circular!) */
    do_fwd = GNUNET_NO;
    return;
  }
  if (bi_hop)
  {
    /* last hop was bi-directional, we could learn something here! */
    struct GNUNET_PeerIdentity path[nhops + 2];
    struct GNUNET_TIME_Relative ilat;
    struct GNUNET_TIME_Relative network_latency;
 
    path[0] = *my_identity;
    path[1] = hops[nhops - 1].hop;   /* direct neighbour == predecessor! */
    for (unsigned int i = 0; i < nhops; i++)
    {
      int iret;
 
      if (0 == (bi_history & (1 << i)))
        break;     /* i-th hop not bi-directional, stop learning! */
      if (i == nhops - 1)
      {
        path[i + 2] = dvl->initiator;
      }
      else
      {
        path[i + 2] = hops[nhops - i - 2].hop;
      }
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Learned inverse path with %u hops to %s\n",
                  i + 2,
                  GNUNET_i2s (&path[i + 2]));
      network_latency = get_network_latency (dvl);
      ilat = GNUNET_TIME_relative_multiply (network_latency, i + 2);
      iret = learn_dv_path (path,
                            i + 3,
                            ilat,
                            GNUNET_TIME_relative_to_absolute (
                              ADDRESS_VALIDATION_LIFETIME));
      if (GNUNET_SYSERR == iret)
      {
        /* path invalid or too long to be interesting for US, thus should also
           not be interesting to our neighbours, cut path when forwarding to
           'i' hops, except of course for the one that goes back to the
           initiator */
        GNUNET_STATISTICS_update (GST_stats,
                                  "# DV learn not forwarded due invalidity of path",
                                  1,
                                  GNUNET_NO);
        do_fwd = GNUNET_NO;
        break;
      }
      if ((GNUNET_NO == iret) && (nhops == i + 1))
      {
        /* we have better paths, and this is the longest target,
           so there cannot be anything interesting later */
        GNUNET_STATISTICS_update (GST_stats,
                                  "# DV learn not forwarded, got better paths",
                                  1,
                                  GNUNET_NO);
        do_fwd = GNUNET_NO;
        break;
      }
    }
  }
  if (MAX_DV_HOPS_ALLOWED == nhops)
  {
    /* At limit, we're out of here! */
    return;
  }
 
  /* Forward to initiator, if path non-trivial and possible */
  bi_history = (bi_history << 1) | (bi_hop ? 1 : 0);
  did_initiator = GNUNET_NO;
  if ((1 <= nhops) &&
      (GNUNET_YES ==
       GNUNET_CONTAINER_multipeermap_contains (neighbours, &dvl->initiator)))
  {
    /* send back to origin! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending DVL back to initiator %s\n",
                GNUNET_i2s (&dvl->initiator));
    forward_dv_learn (&dvl->initiator, dvl, bi_history, nhops, hops, in_time);
    did_initiator = GNUNET_YES;
  }
  /* We forward under two conditions: either we still learned something
     ourselves (do_fwd), or the path was darn short and thus the initiator is
     likely to still be very interested in this (and we did NOT already
     send it back to the initiator) */
  if ((do_fwd) || ((nhops < MIN_DV_PATH_LENGTH_FOR_INITIATOR) &&
                   (GNUNET_NO == did_initiator)))
  {
    /* Pick random neighbours that are not yet on the path */
    struct NeighbourSelectionContext nsc;
    unsigned int n_cnt;
    unsigned int n_eligible;
 
    n_cnt = GNUNET_CONTAINER_multipeermap_size (neighbours);
    nsc.nhops = nhops;
    nsc.dvl = dvl;
    nsc.bi_history = bi_history;
    nsc.hops = hops;
    nsc.in_time = in_time;
    nsc.num_eligible = 0;
    GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                           &dv_neighbour_selection,
                                           &nsc);
    if (0 == nsc.num_eligible)
      return;   /* done here, cannot forward to anyone else */
    n_eligible = nsc.num_eligible;
    nsc.num_selections = calculate_fork_degree (nhops, n_cnt, n_eligible);
    nsc.num_selections =
      GNUNET_MIN (MAX_DV_DISCOVERY_SELECTION, nsc.num_selections);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Forwarding DVL to %u other peers\n",
                nsc.num_selections);
    /* #dv_neighbour_transmission() counts ELIGIBLE peers only, so the
       offsets must be drawn from that range -- drawing from the total
       number of neighbours made us silently forward to fewer peers than
       #calculate_fork_degree() asked for. */
    for (unsigned int i = 0; i < nsc.num_selections; i++)
      nsc.selections[i] =
        (nsc.num_selections == n_eligible)
        ? i   /* all were selected, avoid collisions by chance */
        : GNUNET_CRYPTO_random_u32 (n_eligible);
    nsc.num_eligible = 0;
    GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                           &dv_neighbour_transmission,
                                           &nsc);
  }
}

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_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_PILS_get_identity(), 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_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, my_identity, neighbour_store_dvmono_cb(), neighbours, NeighbourSelectionContext::nhops, NeighbourSelectionContext::num_eligible, TransportDVLearnMessage::num_hops, NeighbourSelectionContext::num_selections, peerstore, pils, DvHopPS::pred, GNUNET_CRYPTO_SignaturePurpose::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

cls	a struct CommunicatorMessageContext
dvb	the send message that was sent

Returns

GNUNET_YES if message is well-formed

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

{
  uint16_t size = ntohs (dvb->header.size);
  uint16_t num_hops = ntohs (dvb->num_hops);
  uint16_t total_hops = ntohs (dvb->total_hops);
  uint16_t orig_size = ntohs (dvb->orig_size);
  const struct GNUNET_PeerIdentity *hops =
    (const struct GNUNET_PeerIdentity *) &dvb[1];
  const struct GNUNET_PeerIdentity *my_identity;
 
  (void) cls;
  if (size < sizeof(*dvb) + num_hops * sizeof(struct GNUNET_PeerIdentity)
      + sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((num_hops > MAX_DV_HOPS_ALLOWED) ||
      (total_hops > MAX_DV_HOPS_ALLOWED))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  /* #decaps_dv_box_cb() derives a VLA size from
     orig_size - sizeof(*dvb) - total_hops * sizeof (struct
     GNUNET_PeerIdentity); make sure that cannot underflow and that the
     remainder can plausibly hold a payload header plus a message. */
  if ((orig_size < size) ||
      (orig_size < sizeof(*dvb)
       + total_hops * sizeof(struct GNUNET_PeerIdentity)
       + sizeof(struct TransportDVBoxPayloadP)
       + sizeof(struct GNUNET_MessageHeader)))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  /* This peer must not be on the path */
  for (unsigned int i = 0; i < num_hops; i++)
    if (0 == GNUNET_memcmp (&hops[i], my_identity))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_break_op, GNUNET_memcmp, GNUNET_PILS_get_identity(), GNUNET_SYSERR, GNUNET_YES, TransportDVBoxMessage::header, MAX_DV_HOPS_ALLOWED, my_identity, TransportDVBoxMessage::num_hops, TransportDVBoxMessage::orig_size, pils, GNUNET_MessageHeader::size, size, and TransportDVBoxMessage::total_hops.

Here is the call graph for this function:

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_hop	peer to receive the message next
total_hops	how many hops did the message take so far
num_hops	length of the hops array
origin	origin of the message
hops	next peer(s) to the destination, including destination
payload	payload of the box
payload_size	number of bytes in payload

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

{
  struct VirtualLink *vl = next_hop->vl;
  struct PendingMessage *pm;
  size_t msg_size = sizeof(struct TransportDVBoxMessage)
                    + num_hops * sizeof(struct GNUNET_PeerIdentity)
                    + enc_payload_size;
  char *buf;
  char msg_buf[msg_size] GNUNET_ALIGN;
  struct GNUNET_PeerIdentity *dhops;
 
  hdr->num_hops = htons (num_hops);
  hdr->total_hops = htons (total_hops);
  hdr->header.size = htons (msg_size);
  memcpy (msg_buf, hdr, sizeof(*hdr));
  dhops = (struct GNUNET_PeerIdentity *) &msg_buf[sizeof(struct
                                                         TransportDVBoxMessage)]
  ;
  memcpy (dhops, hops, num_hops * sizeof(struct GNUNET_PeerIdentity));
  memcpy (&dhops[num_hops], enc_payload, enc_payload_size);
 
  if (GNUNET_YES == ntohl (hdr->without_fc))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Forwarding control message (payload size %u) in DV Box to next hop %s (%u/%u) \n",
                enc_payload_size,
                GNUNET_i2s (&next_hop->pid),
                (unsigned int) num_hops,
                (unsigned int) total_hops);
    route_via_neighbour (next_hop, (const struct
                                    GNUNET_MessageHeader *) msg_buf,
                         RMO_ANYTHING_GOES);
  }
  else
  {
    pm = GNUNET_malloc (sizeof(struct PendingMessage) + msg_size);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "2 created pm %p storing vl %p \n",
                pm,
                vl);
    pm->pmt = PMT_DV_BOX;
    pm->vl = vl;
    pm->target = next_hop->pid;
    pm->timeout = GNUNET_TIME_relative_to_absolute (DV_FORWARD_TIMEOUT);
    pm->logging_uuid = logging_uuid_gen++;
    pm->prefs = GNUNET_MQ_PRIO_BACKGROUND;
    pm->bytes_msg = msg_size;
    buf = (char *) &pm[1];
    memcpy (buf, msg_buf, msg_size);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Created pending message %" PRIu64
                " for DV Box with next hop %s (%u/%u)\n",
                pm->logging_uuid,
                GNUNET_i2s (&next_hop->pid),
                (unsigned int) num_hops,
                (unsigned int) total_hops);
 
    if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
    {
      GNUNET_CONTAINER_MDLL_insert (vl,
                                    vl->pending_msg_head,
                                    vl->pending_msg_tail,
                                    pm);
 
      check_vl_transmission (vl);
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "The virtual link is not ready for forwarding a DV Box with payload, storing PendingMessage in ring buffer.\n");
 
      if (NULL != ring_buffer_dv[ring_buffer_dv_head])
      {
        struct PendingMessage *pm_old = ring_buffer_dv[ring_buffer_dv_head];
 
        GNUNET_free (pm_old);
      }
      ring_buffer_dv[ring_buffer_dv_head] = pm;
      if (RING_BUFFER_SIZE - 1 == ring_buffer_dv_head)
      {
        ring_buffer_dv_head = 0;
        is_ring_buffer_dv_full = GNUNET_YES;
      }
      else
        ring_buffer_dv_head++;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "%u items stored in DV ring buffer\n",
                  GNUNET_YES == is_ring_buffer_dv_full ? RING_BUFFER_SIZE :
                  ring_buffer_dv_head);
    }
  }
}

References PendingMessage::bytes_msg, 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, PendingMessage::logging_uuid, logging_uuid_gen, TransportDVBoxMessage::num_hops, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, Neighbour::pid, PendingMessage::pmt, PMT_DV_BOX, PendingMessage::prefs, ring_buffer_dv, ring_buffer_dv_head, RING_BUFFER_SIZE, RMO_ANYTHING_GOES, route_via_neighbour(), GNUNET_MessageHeader::size, PendingMessage::target, PendingMessage::timeout, TransportDVBoxMessage::total_hops, Neighbour::vl, PendingMessage::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

b	data structure to release

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

{
  if (NULL != b->get)
  {
    GNUNET_PEERSTORE_iteration_stop (b->get);
    b->get = NULL;
    GNUNET_assert (NULL != b->cmc);
    finish_cmc_handling (b->cmc);
    b->cmc = NULL;
  }
  if (NULL != b->task)
  {
    GNUNET_SCHEDULER_cancel (b->task);
    b->task = NULL;
  }
  if (NULL != b->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "store cancel\n");
    GNUNET_PEERSTORE_store_cancel (b->sc);
    b->sc = NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Removing backtalker for %s\n",
              GNUNET_i2s (&b->pid));
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove (backtalkers, &b->pid, b));
  GNUNET_free (b);
}

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

cls	NULL
pid	unused
value	a struct Backtalker

Returns

GNUNET_OK (always)

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

{
  struct Backtalker *b = value;
 
  (void) cls;
  (void) pid;
  free_backtalker (b);
  return GNUNET_OK;
}

References free_backtalker(), GNUNET_OK, Backtalker::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

cls	a struct Backtalker

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

{
  struct Backtalker *b = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "backtalker timeout.\n");
  b->task = NULL;
  if (0 != GNUNET_TIME_absolute_get_remaining (b->timeout).rel_value_us)
  {
    b->task = GNUNET_SCHEDULER_add_at (b->timeout, &backtalker_timeout_cb, b);
    return;
  }
  /* A monotime store may well still be in flight -- @e timeout is about how
     long the *peer* has been quiet, and says nothing about PEERSTORE.  This
     used to `GNUNET_assert (NULL == b->sc)', which aborted the service in
     exactly that case.  #free_backtalker() cancels the store. */
  free_backtalker (b);
}

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

Referenced by backtalker_timeout_cb(), and decaps_dv_box_cont().

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

cls	a struct Backtalker
record	the information found, NULL for the last call
emsg	error message

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

{
  struct Backtalker *b = cls;
  struct GNUNET_TIME_AbsoluteNBO *mtbe;
  struct GNUNET_TIME_Absolute mt;
 
  (void) emsg;
  if (NULL == record)
  {
    struct CommunicatorMessageContext *cmc;
 
    /* we're done with #backtalker_monotime_cb() invocations,
       continue normal processing */
    b->get = NULL;
    GNUNET_assert (NULL != b->cmc);
    /* Take @e cmc out of @a b *before* dispatching: the dispatch runs
       arbitrary message handling, and writing `b->cmc = NULL' afterwards
       is a write to freed memory should anything on that path have
       released @a b.  #free_backtalker() keys its "must finish the parked
       cmc" decision off @e get, which is already NULL here, so clearing
       @e cmc early cannot lose the message either. */
    cmc = b->cmc;
    b->cmc = NULL;
    cmc->mh = (const struct GNUNET_MessageHeader *) &b[1];
    if (0 != b->body_size)
      demultiplex_with_cmc (cmc);
    else
      finish_cmc_handling (cmc);
    return;
  }
  if (sizeof(*mtbe) != record->value_size)
  {
    GNUNET_PEERSTORE_iteration_next (b->get, 1);
    GNUNET_break (0);
    return;
  }
  mtbe = record->value;
  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
  if (mt.abs_value_us > b->monotonic_time.abs_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Backtalker message from %s dropped, monotime in the past\n",
                GNUNET_i2s (&b->pid));
    GNUNET_STATISTICS_update (
      GST_stats,
      "# Backchannel messages dropped: monotonic time not increasing",
      1,
      GNUNET_NO);
    b->monotonic_time = mt;
    /* Setting body_size to 0 prevents call to #forward_backchannel_payload()
     */
    b->body_size = 0;
  }
  GNUNET_PEERSTORE_iteration_next (b->get, 1);
}

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

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

cls	the struct Backtalker
success	GNUNET_OK on success

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

{
  struct Backtalker *b = cls;
 
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store backtalker's monotonic time in PEERSTORE!\n");
  }
  b->sc = NULL;
  /* @e task is armed for the whole life of @a b -- #backtalker_timeout_cb()
     re-arms itself whenever @e timeout has moved forward -- so there is
     nothing to do here beyond releasing the store.  It used to cancel and
     re-add the task, which is what made the task's existence depend on this
     callback ever running. */
  GNUNET_assert (NULL != b->task);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, Backtalker::sc, and Backtalker::task.

Referenced by update_backtalker_monotime().

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

b	a backtalker with updated monotonic time

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

{
  struct GNUNET_TIME_AbsoluteNBO mtbe;
 
  /* At most one store may be outstanding.  The value we are about to write
     supersedes whatever the previous one carried, and leaving the old
     context alive means its completion clears @e sc while the newer store
     is still in flight -- after which the next update sees a NULL @e sc and
     starts a third one.  Cancelling is also what keeps @e sc from being
     silently overwritten and leaked.
 
     Note what this must NOT do: touch @e task.  That task is the only thing
     that ever releases a `struct CommunicatorMessageContext' parked in
     @e cmc, and cancelling it here left its re-arming up to
     #backtalker_monotime_store_cb() -- i.e. up to PEERSTORE answering.  A
     lost store completion then stalled the parked communicator client for
     the life of the process.  #backtalker_timeout_cb() already re-arms
     itself against the current @e timeout, so the task needs no help. */
  if (NULL != b->sc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Superseding in-flight backtalker monotime store %p\n",
                b->sc);
    GNUNET_PEERSTORE_store_cancel (b->sc);
    b->sc = NULL;
  }
  mtbe = GNUNET_TIME_absolute_hton (b->monotonic_time);
  b->sc =
    GNUNET_PEERSTORE_store (peerstore,
                            "transport",
                            &b->pid,
                            GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME,
                            &mtbe,
                            sizeof(mtbe),
                            GNUNET_TIME_UNIT_FOREVER_ABS,
                            GNUNET_PEERSTORE_STOREOPTION_REPLACE,
                            &backtalker_monotime_store_cb,
                            b);
}

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

Referenced by decaps_dv_box_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

decaps_dv_box_cont()

static void decaps_dv_box_cont ( struct CommunicatorMessageContext *  cmc, const struct TransportDVBoxMessage *  dvb, const struct GNUNET_ShortHashCode *  km  )

static

Open the DV box dvb addressed to us, using the key material km decapsulated from its ephemeral key.

Parameters

cmc	context of the message being handled
dvb	the box, valid for the duration of this call
km	decapsulation of dvb's ephemeral_key

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

{
  const unsigned char *hdr;
  size_t hdr_len;
  struct GNUNET_CRYPTO_AeadSecretKey *key;
 
  key = (struct GNUNET_CRYPTO_AeadSecretKey*) km;
  /* We are the ultimate target, so #handle_dv_box() has established that no
     hop entries are left: the ciphertext directly follows the header, and
     its length is what we actually received.  Deriving it from orig_size
     and total_hops instead would only be equivalent if every forwarder
     accounted its skipped hops exactly. */
  hdr = (const unsigned char *) &dvb[1];
  {
    uint16_t size = ntohs (dvb->header.size);
 
    if (size < sizeof(*dvb)
        + sizeof(struct TransportDVBoxPayloadP)
        + sizeof(struct GNUNET_MessageHeader))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    hdr_len = size - sizeof(*dvb);
  }
 
  /* begin actual decryption */
  {
    struct Backtalker *b;
    struct GNUNET_TIME_Absolute monotime;
    struct TransportDVBoxPayloadP *ppay;
    unsigned char pt[hdr_len + sizeof *ppay] GNUNET_ALIGN;
    unsigned char *body;
    const struct GNUNET_MessageHeader *mh;
 
    ppay = (struct TransportDVBoxPayloadP *) pt;
    body = &pt[sizeof *ppay];
    GNUNET_assert (hdr_len >=
                   sizeof(*ppay) + sizeof(struct GNUNET_MessageHeader));
    if (GNUNET_OK != GNUNET_CRYPTO_aead_decrypt (hdr_len,
                                                 hdr,
                                                 0,
                                                 NULL,
                                                 key,
                                                 &dvb->iv,
                                                 &dvb->mac,
                                                 pt))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Error decrypting DV payload header\n");
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    mh = (const struct GNUNET_MessageHeader *) body;
    /* NOTE: this used to compare against `sizeof (body)', i.e. the size of
       a pointer, which meant only 8-byte payloads were ever accepted. */
    if (ntohs (mh->size) != hdr_len - sizeof(*ppay))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    /* need to prevent box-in-a-box (and DV_LEARN) so check inbox type! */
    switch (ntohs (mh->type))
    {
    case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX:
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
 
    case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN:
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
 
    default:
      /* permitted, continue */
      break;
    }
    monotime = GNUNET_TIME_absolute_ntoh (ppay->monotonic_time);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Decrypted backtalk from %s\n",
                GNUNET_i2s (&ppay->sender));
    b = GNUNET_CONTAINER_multipeermap_get (backtalkers,
                                           &ppay->sender);
    if ((NULL != b) && (monotime.abs_value_us < b->monotonic_time.abs_value_us))
    {
      GNUNET_STATISTICS_update (
        GST_stats,
        "# Backchannel messages dropped: monotonic time not increasing",
        1,
        GNUNET_NO);
      finish_cmc_handling (cmc);
      return;
    }
    if ((NULL == b) ||
        (0 != GNUNET_memcmp (&b->last_ephemeral, &dvb->ephemeral_key)))
    {
      /* Check signature */
      const struct GNUNET_PeerIdentity *my_identity;
      struct EphemeralConfirmationPS ec;
 
      my_identity = GNUNET_PILS_get_identity (pils);
      GNUNET_assert (my_identity);
 
      ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
      ec.target = *my_identity;
      ec.ephemeral_key = dvb->ephemeral_key;
      ec.purpose.size =  htonl (sizeof(ec));
      ec.sender_monotonic_time = ppay->monotonic_time;
      if (
        GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_verify (
          GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL,
          &ec,
          &ppay->sender_sig,
          &ppay->sender.public_key))
      {
        /* Signature invalid, discard! */
        GNUNET_break_op (0);
        finish_cmc_handling (cmc);
        return;
      }
    }
    /* Update sender, we now know the real origin! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "DVBox received for me from %s via %s\n",
                GNUNET_i2s2 (&ppay->sender),
                GNUNET_i2s (&cmc->im.sender));
    cmc->im.sender = ppay->sender;
 
    if (NULL != b)
    {
      /* update key cache and mono time */
      b->last_ephemeral = dvb->ephemeral_key;
      b->monotonic_time = monotime;
      update_backtalker_monotime (b);
      b->timeout =
        GNUNET_TIME_relative_to_absolute (BACKCHANNEL_INACTIVITY_TIMEOUT);
      cmc->mh = mh;
      demultiplex_with_cmc (cmc);
      return;
    }
    /* setup data structure to cache signature AND check
       monotonic time with PEERSTORE before forwarding backchannel payload */
    b = GNUNET_malloc (sizeof(struct Backtalker) + (hdr_len - sizeof(*ppay)));
    b->pid = ppay->sender;
    b->body_size = hdr_len - sizeof(*ppay);
    memcpy (&b[1], body, hdr_len - sizeof(*ppay));
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multipeermap_put (
                     backtalkers,
                     &b->pid,
                     b,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    b->monotonic_time = monotime; /* NOTE: to be checked still! */
    b->cmc = cmc;
    b->timeout =
      GNUNET_TIME_relative_to_absolute (BACKCHANNEL_INACTIVITY_TIMEOUT);
    b->task = GNUNET_SCHEDULER_add_at (b->timeout, &backtalker_timeout_cb, b);
    b->get =
      GNUNET_PEERSTORE_iteration_start (peerstore,
                                        "transport",
                                        &b->pid,
                                        GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME,
                                        &backtalker_monotime_cb,
                                        b);
  } /* end actual decryption */
}

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(), EphemeralConfirmationPS::ephemeral_key, TransportDVBoxMessage::ephemeral_key, finish_cmc_handling(), Backtalker::get, GNUNET_ALIGN, GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_aead_decrypt(), GNUNET_CRYPTO_eddsa_verify, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, 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_PILS_get_identity(), GNUNET_SCHEDULER_add_at(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, GST_stats, TransportDVBoxMessage::header, CommunicatorMessageContext::im, TransportDVBoxMessage::iv, key, Backtalker::last_ephemeral, TransportDVBoxMessage::mac, mh, CommunicatorMessageContext::mh, TransportDVBoxPayloadP::monotonic_time, Backtalker::monotonic_time, my_identity, peerstore, Backtalker::pid, pils, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_SignaturePurpose::purpose, EphemeralConfirmationPS::purpose, TransportDVBoxPayloadP::sender, GNUNET_TRANSPORT_IncomingMessage::sender, EphemeralConfirmationPS::sender_monotonic_time, TransportDVBoxPayloadP::sender_sig, GNUNET_MessageHeader::size, GNUNET_CRYPTO_SignaturePurpose::size, size, EphemeralConfirmationPS::target, Backtalker::task, Backtalker::timeout, and update_backtalker_monotime().

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
dvb	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  uint16_t size = ntohs (dvb->header.size) - sizeof(*dvb);
  uint16_t num_hops = ntohs (dvb->num_hops);
  const struct GNUNET_PeerIdentity *hops =
    (const struct GNUNET_PeerIdentity *) &dvb[1];
  const char *enc_payload = (const char *) &hops[num_hops];
  uint16_t enc_payload_size =
    size - (num_hops * sizeof(struct GNUNET_PeerIdentity));
  const struct GNUNET_PeerIdentity *my_identity;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  if (GNUNET_EXTRA_LOGGING > 0)
  {
    char *path;
 
    path = GNUNET_strdup (GNUNET_i2s (my_identity));
    for (unsigned int i = 0; i < num_hops; i++)
    {
      char *tmp;
 
      GNUNET_asprintf (&tmp, "%s->%s", path, GNUNET_i2s (&hops[i]));
      GNUNET_free (path);
      path = tmp;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received DVBox with remaining path %s\n",
                path);
    GNUNET_free (path);
  }
 
  if (num_hops > 0)
  {
    /* We're trying from the end of the hops array, as we may be
       able to find a shortcut unknown to the origin that way */
    for (int i = num_hops - 1; i >= 0; i--)
    {
      struct Neighbour *n;
 
      if (0 == GNUNET_memcmp (&hops[i], my_identity))
      {
        GNUNET_break_op (0);
        finish_cmc_handling (cmc);
        return;
      }
      n = lookup_neighbour (&hops[i]);
      if (NULL == n)
        continue;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Skipping %u/%u hops ahead while routing DV Box\n",
                  i,
                  num_hops);
 
      forward_dv_box (n,
                      (struct TransportDVBoxMessage *) dvb,
                      /* we strip i+1 entries, and the receiver reconstructs
                         the ciphertext offset from total_hops */
                      ntohs (dvb->total_hops) + i + 1,
                      num_hops - i - 1,    /* number of hops left */
                      &hops[i + 1],    /* remaining hops */
                      enc_payload,
                      enc_payload_size);
      GNUNET_STATISTICS_update (GST_stats,
                                "# DV hops skipped routing boxes",
                                i,
                                GNUNET_NO);
      GNUNET_STATISTICS_update (GST_stats,
                                "# DV boxes routed (total)",
                                1,
                                GNUNET_NO);
      finish_cmc_handling (cmc);
      return;
    }
    /* Woopsie, next hop not in neighbours, drop! */
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV Boxes dropped: next hop unknown",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  /* We are the target. Unbox and handle message. */
  GNUNET_STATISTICS_update (GST_stats,
                            "# DV boxes opened (ultimate target)",
                            1,
                            GNUNET_NO);
  cmc->total_hops = ntohs (dvb->total_hops);
 
  {
    // DH key derivation with received DV, could be garbage.
    const struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
    struct GNUNET_ShortHashCode km;
 
    my_private_key = GNUNET_PILS_get_private_key (pils);
    if ( (NULL == my_private_key) ||
         (GNUNET_OK !=
          GNUNET_CRYPTO_eddsa_kem_decaps (my_private_key,
                                          &dvb->ephemeral_key,
                                          &km)) )
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
    decaps_dv_box_cont (cmc,
                        dvb,
                        &km);
  }
}

References decaps_dv_box_cont(), TransportDVBoxMessage::ephemeral_key, finish_cmc_handling(), forward_dv_box(), GNUNET_asprintf(), GNUNET_assert, GNUNET_break_op, GNUNET_CRYPTO_eddsa_kem_decaps(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_EXTRA_LOGGING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_PILS_get_private_key(), GNUNET_STATISTICS_update(), GNUNET_strdup, GST_stats, TransportDVBoxMessage::header, lookup_neighbour(), my_identity, my_private_key, TransportDVBoxMessage::num_hops, pils, GNUNET_MessageHeader::size, size, TransportDVBoxMessage::total_hops, and CommunicatorMessageContext::total_hops.

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

cls	a struct TransportClient which sent us the message
im	the send message that was sent

Returns

GNUNET_YES if message is well-formed

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

{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_MQ_check_boxed_message (im);
  return GNUNET_OK;
}

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

cls	a struct CheckKnownAddressContext
pid	unused (must match though)
value	a struct ValidationState

Returns

GNUNET_OK if not matching, GNUNET_NO if match found

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

{
  struct CheckKnownAddressContext *ckac = cls;
  struct ValidationState *vs = value;
 
  (void) pid;
  if (0 != strcmp (vs->address, ckac->address))
    return GNUNET_OK;
  ckac->vs = vs;
  return GNUNET_NO;
}

References CheckKnownAddressContext::address, GNUNET_NO, GNUNET_OK, ValidationState::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

cls

NULL

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

{
  struct ValidationState *vs;
  struct Queue *q;
  const struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get_monotonic (
    GST_cfg);
 
  (void) cls;
  validation_task = NULL;
  vs = GNUNET_CONTAINER_heap_peek (validation_heap);
  /* drop validations past their expiration */
  while (
    (NULL != vs) &&
    (0 == GNUNET_TIME_absolute_get_remaining (vs->valid_until).rel_value_us))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Validation response %s cleaned up\n",
                GNUNET_sh2s (&vs->challenge.value));
    free_validation_state (vs);
    vs = GNUNET_CONTAINER_heap_peek (validation_heap);
  }
  if (NULL == vs)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Address validation task not scheduled anymore, nothing to do\n");
    return;   /* woopsie, no more addresses known, should only
                 happen if we're really a lonely peer */
  }
  q = find_queue (&vs->pid, vs->address);
  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "To early to start next address validation for challenge %s\n",
                GNUNET_sh2s (&vs->challenge.value));
    /* Do NOT just return: @e validation_task was set to NULL above and
       nothing re-arms it by itself.  #update_next_challenge_time() only
       schedules us again when it is called with a *changed* time for some
       validation state, so bailing out here leaves a non-empty
       #validation_heap with no task attached: address (re)validation and
       the #suggest_to_connect() retries that go with it stop for *every*
       peer until some unrelated event happens to come along.  A peer that
       just lost its only connection has no such events left. */
    validation_task =
      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_difference (
                                      now,
                                      vs->first_challenge_use),
                                    &validation_start_cb,
                                    NULL);
    return;
  }
  if (NULL == q)
  {
    vs->awaiting_queue = GNUNET_YES;
    suggest_to_connect (&vs->pid, vs->address);
  }
  else
    validation_transmit_on_queue (q, vs);
  /* Finally, reschedule next attempt */
  vs->challenge_backoff =
    GNUNET_TIME_randomized_backoff (vs->challenge_backoff,
                                    validation_challenge_freq (&vs->pid));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Address validation task will run again in %s\n",
              GNUNET_STRINGS_relative_time_to_string (vs->challenge_backoff,
                                                      GNUNET_YES));
  update_next_challenge_time (vs,
                              GNUNET_TIME_relative_to_absolute (
                                vs->challenge_backoff));
}

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

Referenced by update_next_challenge_time(), and validation_start_cb().

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

vs	validation state to update
new_time	new time for revalidation

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

{
  struct GNUNET_TIME_Relative delta;
  struct ValidationState *next;
 
  /* NOTE: "be lazy" must not apply while #validation_task is unset.  Our
     only caller that can leave it unset is #validation_start_cb(), which
     NULLs it on entry and relies on us to arm it again -- and nothing else
     ever does.  Returning early there stops address (re)validation and the
     #suggest_to_connect() retries that go with it for *every* peer, for
     good. */
  if ((new_time.abs_value_us == vs->next_challenge.abs_value_us) &&
      (NULL != validation_task) &&
      (NULL != vs->hn))
    return; /* be lazy */
  vs->next_challenge = new_time;
  if (NULL == vs->hn)
    vs->hn =
      GNUNET_CONTAINER_heap_insert (validation_heap, vs, new_time.abs_value_us);
  else
    GNUNET_CONTAINER_heap_update_cost (vs->hn, new_time.abs_value_us);
  if ((vs != GNUNET_CONTAINER_heap_peek (validation_heap)) &&
      (NULL != validation_task))
    return;
  if (NULL != validation_task)
    GNUNET_SCHEDULER_cancel (validation_task);
  /* Arm for the earliest entry in the heap, which need NOT be @a vs:
     #validation_start_cb() calls us with @e validation_task unset and with
     @a vs already pushed out to its new @e challenge_backoff, which doubles
     up to #MAX_VALIDATION_CHALLENGE_FREQ (one day) while an address stays
     unanswered.  Arming for @a vs there parks the single global validation
     task for that long, no matter how many other addresses are due right
     now -- and every address of a peer we cannot reach (NAT) is such an
     address.  Everything that needs a validation then stops with it:
     bringing a lost link back up, and confirming the link to a peer that
     contacted us. */
  next = GNUNET_CONTAINER_heap_peek (validation_heap);
  if (NULL == next)
    return;
  /* randomize a bit */
  delta.rel_value_us =
    GNUNET_CRYPTO_random_u64 (MIN_DELAY_ADDRESS_VALIDATION.rel_value_us);
  validation_task =
    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_add (next->next_challenge,
                                                       delta),
                             &validation_start_cb,
                             NULL);
}

References GNUNET_TIME_Absolute::abs_value_us, delta, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_heap_update_cost(), 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(), revalidate_now_cb(), 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:

speed_up_challenge()

static void speed_up_challenge ( struct ValidationState *  vs )

static

Speed the next challenge for vs up because we heard something about that address again – but never faster than FAST_VALIDATION_CHALLENGE_FREQ.

The callers used to write min (FAST, backoff / 2), which is ZERO whenever challenge_backoff is zero – and handle_validation_response() clears it after every successful validation, while update_next_challenge_time() then arms the global validation_task for "now". Since send_t_validation_response() ends in try_to_bring_link_up() for every challenge we answer on an unconfirmed link, two peers that cannot confirm each other then challenge each other once per round trip – two EdDSA signatures, two verifications and a PEERSTORE store per exchange, per peer, forever. FAST is documented as the fastest rate at which we challenge an address we keep hearing about, so it is both cap and floor here; the first challenge for a new address is still immediate.

Parameters

vs	address validation state to speed up

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

{
  vs->challenge_backoff = FAST_VALIDATION_CHALLENGE_FREQ;
}

References FAST_VALIDATION_CHALLENGE_FREQ.

Referenced by revalidate_now_cb(), and start_address_validation().

Here is the caller graph for this function:

revalidate_now_cb()

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

static

Pull value's next challenge forward: the link to that peer is not up.

Touches only validation_heap, so it is safe to run while iterating validation_map.

Parameters

cls	NULL
pid	peer the validation state belongs to
value	a struct ValidationState

Returns

GNUNET_OK (continue to iterate)

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

{
  struct ValidationState *vs = value;
  const struct GNUNET_TIME_Absolute now =
    GNUNET_TIME_absolute_get_monotonic (GST_cfg);
 
  (void) cls;
  (void) pid;
  /* What #start_address_validation() does for an address it hears about
     again, but without needing the address string. */
  speed_up_challenge (vs);
  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
    vs->first_challenge_use = now;
  update_next_challenge_time (vs,
                              GNUNET_TIME_relative_to_absolute (
                                vs->challenge_backoff));
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_TIME_absolute_cmp, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_relative_to_absolute(), GST_cfg, speed_up_challenge(), update_next_challenge_time(), and value.

Referenced by try_to_bring_link_up().

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

pid	peer the queue must go to
address	address the queue must use

Returns

NULL if no such queue exists

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

{
  struct Neighbour *n;
 
  n = lookup_neighbour (pid);
  if (NULL == n)
    return NULL;
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    if (0 == strcmp (pos->address, address))
      return pos;
  }
  return NULL;
}

References address, lookup_neighbour(), 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

pid	target peer
address	the address to try

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

{
  static uint32_t idgen = 0;
  struct TransportClient *tc;
  char *prefix;
  struct GNUNET_TRANSPORT_CreateQueue *cqm;
  struct GNUNET_MQ_Envelope *env;
  size_t alen;
 
  prefix = GNUNET_HELLO_address_to_prefix (address);
  if (NULL == prefix)
  {
    GNUNET_break (0);  /* We got an invalid address!? */
    return;
  }
  tc = lookup_communicator (prefix);
  if (NULL == tc)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# Suggestions ignored due to missing communicator",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Cannot connect to %s at `%s', no matching communicator present\n",
                GNUNET_i2s (pid),
                address);
    GNUNET_free (prefix);
    return;
  }
  /* forward suggestion for queue creation to communicator */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Request #%u for `%s' communicator to create queue to `%s' at `%s'\n",
              (unsigned int) idgen,
              prefix,
              GNUNET_i2s (pid),
              address);
  GNUNET_free (prefix);
  alen = strlen (address) + 1;
  env =
    GNUNET_MQ_msg_extra (cqm, alen, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE);
  cqm->request_id = htonl (idgen++);
  cqm->receiver = *pid;
  memcpy (&cqm[1], address, alen);
  GNUNET_MQ_send (tc->mq, env);
}

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(), 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 10773 of file gnunet-service-transport.c.

{
  struct Queue *q;
  int pfx_len;
  const char *eou;
  char *address;
  (void) cls;
 
  eou = strstr (uri,
                "://");
  if ((NULL == eou) || (eou == uri))
  {
    /* @a uri comes from a HELLO some remote peer published. */
    GNUNET_break_op (0);
    return;
  }
  pfx_len = eou - uri;
  eou += 3;
  GNUNET_asprintf (&address,
                   "%.*s-%s",
                   pfx_len,
                   uri,
                   eou);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "helo for client %s\n",
              address);
  q = find_queue (pid, address);
  if (NULL == q)
  {
    suggest_to_connect (pid, address);
  }
  else
    start_address_validation (pid, address);
  GNUNET_free (address);
}

References address, find_queue(), GNUNET_asprintf(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, 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:

hello_from_record()

static const struct GNUNET_MessageHeader * hello_from_record ( const struct GNUNET_PEERSTORE_Record *  record )

static

Obtain the HELLO message stored in record, if record actually carries one.

PEERSTORE values are opaque blobs: handle_store() of the PEERSTORE service performs no validation whatsoever, and the records under GNUNET_PEERSTORE_HELLO_KEY originate from other peers (via the DHT, the hostlist daemon and topology gossip). So the length of the value and the length the embedded message claims to have are two independent numbers, and neither may be trusted:

• a zero-length value leaves value at NULL (see PEERSTORE_parse_record_message()), and GNUNET_HELLO_parser_from_msg() dereferences its argument unconditionally – that is a NULL dereference;
• a value shorter than a message header, or one whose size field exceeds value_size, makes the parser read past the end of the heap block the record was parsed into.

Parameters

record

record to inspect, may be NULL

Returns

the HELLO, or NULL if record does not hold a well-formed one

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

{
  const struct GNUNET_MessageHeader *hello;
 
  if ((NULL == record) ||
      (NULL == record->value) ||
      (record->value_size < sizeof(*hello)))
  {
    GNUNET_break_op (0);
    return NULL;
  }
  hello = record->value;
  if (ntohs (hello->size) > record->value_size)
  {
    GNUNET_break_op (0);
    return NULL;
  }
  return hello;
}

References GNUNET_break_op, record(), and GNUNET_MessageHeader::size.

Referenced by check_for_burst_address(), check_for_global_natted(), handle_hello_for_client(), and 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

cls	closure, a struct IncomingRequest
record	peerstore record information
emsg	error message, or NULL if no errors

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

{
  struct IncomingRequest *ir = cls;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_MessageHeader *hello;
  const struct GNUNET_PeerIdentity *my_identity;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  hello = hello_from_record (record);
  if (NULL == hello)
  {
    /* MUST still ask for the next record: a bad one is not a reason to
       stall this monitor forever. */
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  if (0 == GNUNET_memcmp (&record->peer, my_identity))
  {
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  if (0 != GNUNET_memcmp (&record->peer, &ir->pid))
  {
    /* Not the peer this request is about. */
    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
    return;
  }
  parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
  if (NULL != parser)
  {
    GNUNET_HELLO_parser_iterate (parser,
                                 hello_for_incoming_cb,
                                 NULL);
    GNUNET_HELLO_parser_free (parser);
  }
  /* MUST ask for the next record, or this monitor stalls after one HELLO */
  GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
}

References GNUNET_break, 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(), GNUNET_PILS_get_identity(), hello_for_incoming_cb(), hello_from_record(), my_identity, IncomingRequest::nc, IncomingRequest::pid, pils, and record().

Referenced by try_to_bring_link_up().

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by try_to_bring_link_up().

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Done with initial PEERSTORE iteration during monitoring\n");
}

References GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by try_to_bring_link_up().

Here is the caller graph for this function:

send_t_validation_response()

static void send_t_validation_response ( struct CommunicatorMessageContext *  cmc, struct TransportValidationResponseMessage  tvr  )

static

Route the signed validation response tvr back to the challenger and release cmc.

Parameters

cmc	context of the challenge we are answering
tvr	the response, signature already filled in

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

{
  struct VirtualLink *vl;
  struct Neighbour *n;
  struct GNUNET_PeerIdentity sender;
 
  sender = cmc->im.sender;
  vl = lookup_virtual_link (&sender);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    // route_control_message_without_fc (&cmc->im.sender,
    route_control_message_without_fc (vl,
                                      &tvr.header,
                                      RMO_ANYTHING_GOES | RMO_REDUNDANT);
  }
  else
  {
    /* Use route via neighbour */
    n = lookup_neighbour (&sender);
    if (NULL != n)
      route_via_neighbour (n, &tvr.header,
                           RMO_ANYTHING_GOES | RMO_REDUNDANT
                           | RMO_UNCONFIRMED_ALLOWED);
  }
 
  finish_cmc_handling (cmc);
  /* An *unconfirmed* link is not a link -- it carries nothing, and CORE has
     never been told about the peer.  Bailing out on one merely because it
     exists is what deadlocks a pair of peers into permanent one-way state:
     the challenger validated us, so it believes the connection is up and
     starts sending us FLOW_CONTROL; #handle_flow_control() answers an
     unknown sender by allocating exactly such an unconfirmed link; and from
     then on every challenge it retransmits lands here, gets a response --
     which keeps *its* side confirmed and its RTT healthy -- and returns
     without ever validating an address of its own.  The unconfirmed link
     reaps itself after #UNCONFIRMED_LINK_TIMEOUT, but the next FLOW_CONTROL
     recreates it, and the peer keeps sending those precisely because it
     thinks it is connected.  Nothing ever breaks the tie, so CORE on this
     side never hears about the peer and never answers its handshake.
     Only a confirmed link means there is nothing left to do. */
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
    return;
 
  /* For us, the link is still down, but we need bi-directional
     connections (for flow-control and for this to be useful for
     CORE), so we must try to bring the link up! */
  try_to_bring_link_up (&sender);
}

References VirtualLink::confirmed, finish_cmc_handling(), GNUNET_YES, TransportValidationResponseMessage::header, CommunicatorMessageContext::im, lookup_neighbour(), lookup_virtual_link(), RMO_ANYTHING_GOES, RMO_REDUNDANT, RMO_UNCONFIRMED_ALLOWED, route_control_message_without_fc(), route_via_neighbour(), GNUNET_TRANSPORT_IncomingMessage::sender, and try_to_bring_link_up().

Referenced by handle_validation_challenge().

Here is the call graph for this function:

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
tvc	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  struct TransportValidationResponseMessage tvr = { 0 };
  struct GNUNET_TIME_RelativeNBO validity_duration;
 
  /* DV-routed messages are not allowed for validation challenges */
  if (cmc->total_hops > 0)
  {
    GNUNET_break_op (0);
    finish_cmc_handling (cmc);
    return;
  }
  validity_duration = cmc->im.expected_address_validity;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received address validation challenge %s\n",
              GNUNET_sh2s (&tvc->challenge.value));
  /* If we have a virtual link, we use this mechanism to signal the
     size of the flow control window, and to allow the sender
     to ask for increases. If for us the virtual link is still down,
     we will always give a window size of zero. */
  tvr.header.type =
    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE);
  tvr.header.size = htons (sizeof(tvr));
  tvr.reserved = htonl (0);
  tvr.challenge = tvc->challenge;
  tvr.origin_time = tvc->sender_time;
  tvr.validity_duration = validity_duration;
  {
    /* create signature */
    struct TransportValidationPS tvp = {
      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
      .purpose.size = htonl (sizeof(tvp)),
      .validity_duration = validity_duration,
      .challenge = tvc->challenge
    };
    if (GNUNET_OK != sign_by_my_identity (&tvp.purpose, &tvr.signature))
    {
      /* Not answering costs us this address validation; leaving @a cmc
         behind would cost us the communicator. */
      finish_cmc_handling (cmc);
      return;
    }
  }
  send_t_validation_response (cmc, tvr);
}

References TransportValidationChallengeMessage::challenge, TransportValidationResponseMessage::challenge, GNUNET_TRANSPORT_IncomingMessage::expected_address_validity, finish_cmc_handling(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE, GNUNET_OK, GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE, TransportValidationResponseMessage::header, CommunicatorMessageContext::im, GNUNET_CRYPTO_SignaturePurpose::purpose, TransportValidationPS::purpose, TransportValidationResponseMessage::reserved, send_t_validation_response(), TransportValidationChallengeMessage::sender_time, sign_by_my_identity(), TransportValidationResponseMessage::signature, GNUNET_MessageHeader::size, 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

cls	a struct CheckKnownChallengeContext
pid	unused (must match though)
value	a struct ValidationState

Returns

GNUNET_OK if not matching, GNUNET_NO if match found

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

{
  struct CheckKnownChallengeContext *ckac = cls;
  struct ValidationState *vs = value;
 
  (void) pid;
  if (0 != GNUNET_memcmp (&vs->challenge, ckac->challenge))
    return GNUNET_OK;
  ckac->vs = vs;
  return GNUNET_NO;
}

References CheckKnownChallengeContext::challenge, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, ValidationState::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

cls	a struct ValidationState
success	GNUNET_YES on success

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

{
  struct ValidationState *vs = cls;
 
  vs->sc = NULL;
  if (GNUNET_YES == success)
    return;
  GNUNET_STATISTICS_update (GST_stats,
                            "# Peerstore failed to store foreign address",
                            1,
                            GNUNET_NO);
}

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:

find_queue_by_ip()

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

static

Find a queue to pid whose address has the same IP as address, but possibly a different port.

This mirrors the (deliberately) loose matching done by check_validation_request_pending(): a validation may legitimately be transmitted on a queue whose address is not literally address, because for a NATed peer the address we asked to connect to (‘PROTO-IP:0’) and the address the resulting queue ends up with (‘PROTO-IP:port’) differ. When the validation then succeeds we must be able to find that queue again.

Parameters

pid	peer the queue must go to
address	address whose IP the queue must use

Returns

NULL if no such queue exists

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

{
  struct Neighbour *n;
  struct Queue *ret = NULL;
  char *prefix;
  char *ip;
 
  n = lookup_neighbour (pid);
  if (NULL == n)
    return NULL;
  prefix = GNUNET_HELLO_address_to_prefix (address);
  ip = get_address_without_port (address);
  if ((NULL == prefix) || (NULL == ip))
  {
    GNUNET_free (prefix);
    GNUNET_free (ip);
    return NULL;
  }
  for (struct Queue *pos = n->queue_head; NULL != pos;
       pos = pos->next_neighbour)
  {
    char *q_prefix = GNUNET_HELLO_address_to_prefix (pos->address);
    char *q_ip = get_address_without_port (pos->address);
 
    /* Same communicator and same host -- only the port may differ. */
    if ((NULL != q_prefix) && (NULL != q_ip) &&
        (0 == strcmp (q_prefix, prefix)) &&
        (0 == strcmp (q_ip, ip)))
      ret = pos;
    GNUNET_free (q_prefix);
    GNUNET_free (q_ip);
    if (NULL != ret)
      break;
  }
  GNUNET_free (prefix);
  GNUNET_free (ip);
  return ret;
}

References address, get_address_without_port(), GNUNET_free, GNUNET_HELLO_address_to_prefix(), lookup_neighbour(), prefix, Neighbour::queue_head, and ret.

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

q	queue to send on
vs	state to derive validation challenge from

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

{
  struct TransportValidationChallengeMessage tvc;
  struct GNUNET_TIME_Absolute monotonic_time;
 
  if (NULL != vs->revalidation_task)
  {
    GNUNET_SCHEDULER_cancel (vs->revalidation_task);
    vs->revalidation_task = NULL;
  }
  /*memcpy (&hkey,
          &hc,
          sizeof (hkey));*/
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Remove key %s for address %s map size %u contains %u\n",
              GNUNET_h2s (&vs->hc),
              vs->address,
              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
                                                      &vs->hc));
  GNUNET_CONTAINER_multihashmap_remove (revalidation_map, &vs->hc, vs);
 
  monotonic_time  = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
  if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
      vs->last_challenge_use.abs_value_us)
  {
    vs->first_challenge_use = monotonic_time;
  }
  vs->last_challenge_use = monotonic_time;
  tvc.header.type =
    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE);
  tvc.header.size = htons (sizeof(tvc));
  tvc.reserved = htonl (0);
  tvc.challenge = vs->challenge;
  tvc.sender_time = GNUNET_TIME_absolute_hton (vs->last_challenge_use);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Sending address validation challenge %s to %s\n",
              GNUNET_sh2s (&tvc.challenge.value),
              GNUNET_i2s (&q->neighbour->pid));
  queue_send_msg (q, NULL, &tvc, sizeof(tvc));
}

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

{
  struct ValidationState *vs = cls;
  struct Queue *q;
  struct GNUNET_TIME_Absolute now;
 
  vs->revalidation_task = NULL;
  q = find_queue (&vs->pid, vs->address);
  if (NULL == q)
  {
    now = GNUNET_TIME_absolute_get ();
    vs->awaiting_queue = GNUNET_YES;
    suggest_to_connect (&vs->pid, vs->address);
    update_next_challenge_time (vs, now);
  }
  else
    validation_transmit_on_queue (q, vs);
}

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

{
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Key in revalidate map  %s \n",
              GNUNET_h2s (key));
  return GNUNET_YES;
}

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
tvr	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  struct ValidationState *vs;
  struct CheckKnownChallengeContext ckac = { .challenge = &tvr->challenge,
                                             .vs = NULL};
  struct GNUNET_TIME_Absolute origin_time;
  struct Queue *q;
  struct Neighbour *n;
  struct VirtualLink *vl;
  const struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get_monotonic (
    GST_cfg);
 
  /* check this is one of our challenges */
  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
                                                     &cmc->im.sender,
                                                     &check_known_challenge,
                                                     &ckac);
  if (NULL == (vs = ckac.vs))
  {
    /* This can happen simply if we 'forgot' the challenge by now,
       i.e. because we received the validation response twice */
    GNUNET_STATISTICS_update (GST_stats,
                              "# Validations dropped, challenge unknown",
                              1,
                              GNUNET_NO);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Validation response %s dropped, challenge unknown\n",
                GNUNET_sh2s (&tvr->challenge.value));
    finish_cmc_handling (cmc);
    return;
  }
 
  /* sanity check on origin time */
  origin_time = GNUNET_TIME_absolute_ntoh (tvr->origin_time);
  if ((origin_time.abs_value_us < vs->first_challenge_use.abs_value_us) ||
      (origin_time.abs_value_us > vs->last_challenge_use.abs_value_us))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Diff first use %" PRIu64 " and last use %" PRIu64 "\n",
                vs->first_challenge_use.abs_value_us - origin_time.abs_value_us,
                origin_time.abs_value_us - vs->last_challenge_use.abs_value_us);
    GNUNET_break_op (0);
    finish_cmc_handling (cmc);
    return;
  }
 
  {
    /* check signature */
    struct TransportValidationPS tvp = {
      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
      .purpose.size = htonl (sizeof(tvp)),
      .validity_duration = tvr->validity_duration,
      .challenge = tvr->challenge
    };
 
    if (
      GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE,
                                  &tvp,
                                  &tvr->signature,
                                  &cmc->im.sender.public_key))
    {
      GNUNET_break_op (0);
      finish_cmc_handling (cmc);
      return;
    }
  }
 
  /* validity is capped by our willingness to keep track of the
     validation entry and the maximum the other peer allows */
  vs->valid_until = GNUNET_TIME_relative_to_absolute (
    GNUNET_TIME_relative_min (GNUNET_TIME_relative_ntoh (
                                tvr->validity_duration),
                              MAX_ADDRESS_VALID_UNTIL));
  vs->validated_until =
    GNUNET_TIME_absolute_min (vs->valid_until,
                              GNUNET_TIME_relative_to_absolute (
                                ADDRESS_VALIDATION_LIFETIME));
  vs->validation_rtt = GNUNET_TIME_absolute_get_duration (origin_time);
  vs->challenge_backoff = GNUNET_TIME_UNIT_ZERO;
  GNUNET_CRYPTO_random_block (&vs->challenge,
                              sizeof(vs->challenge));
  vs->first_challenge_use = GNUNET_TIME_absolute_subtract (
    vs->validated_until,
    GNUNET_TIME_relative_multiply (vs->validation_rtt,
                                   VALIDATION_RTT_BUFFER_FACTOR));
  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, <, now))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "First challenge use is now %" PRIu64 " %s \n",
                vs->first_challenge_use.abs_value_us,
                GNUNET_sh2s (&vs->challenge.value));
    vs->first_challenge_use = now;
  }
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "First challenge use is later %" PRIu64 " %s \n",
                vs->first_challenge_use.abs_value_us,
                GNUNET_sh2s (&vs->challenge.value));
  vs->last_challenge_use =
    GNUNET_TIME_UNIT_ZERO_ABS; /* challenge was not yet used */
  update_next_challenge_time (vs, vs->first_challenge_use);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Validation response %s from %s accepted, address valid until %s\n",
              GNUNET_sh2s (&tvr->challenge.value),
              GNUNET_i2s (&cmc->im.sender),
              GNUNET_STRINGS_absolute_time_to_string (vs->valid_until));
  /*memcpy (&hkey,
          &hc,
          sizeof (hkey));*/
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Key %s for address %s map size %u contains %u\n",
              GNUNET_h2s (&vs->hc),
              vs->address,
              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
                                                      &vs->hc));
  /* NOTE: @e hc hashes the address only, so two `struct ValidationState's
     for different peers can collide here.  That must not abort us. */
  if (GNUNET_YES !=
      GNUNET_CONTAINER_multihashmap_put (
        revalidation_map,
        &vs->hc,
        vs,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Address `%s' already tracked for revalidation\n",
                vs->address);
  GNUNET_CONTAINER_multihashmap_iterate (revalidation_map,
                                         revalidate_map_it,
                                         NULL);
  vs->revalidation_task =
    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_subtract (vs->next_challenge,
                                                            GNUNET_TIME_UNIT_MINUTES),
                             &revalidation_start_cb, vs);
  vs->sc = GNUNET_PEERSTORE_store (peerstore,
                                   "transport",
                                   &cmc->im.sender,
                                   GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY,
                                   vs->address,
                                   strlen (vs->address) + 1,
                                   vs->valid_until,
                                   GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
                                   &peerstore_store_validation_cb,
                                   vs);
  finish_cmc_handling (cmc);
 
  /* Finally, we now possibly have a confirmed (!) working queue,
     update queue status (if queue still is around) */
  q = find_queue (&vs->pid, vs->address);
  if (NULL == q)
  {
    /* The challenge may have gone out on a queue whose address is not
       literally @e address: #check_validation_request_pending() matches on
       the IP alone, precisely so that a validation waiting for the NAT
       address `PROTO-IP:0' can be answered over the queue that the peer
       actually established from `PROTO-IP:port'.  Insisting on an exact
       match here would silently discard that (successful!) validation and
       never bring the virtual link up. */
    q = find_queue_by_ip (&vs->pid, vs->address);
  }
  if (NULL == q)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# Queues lost at time of successful validation",
                              1,
                              GNUNET_NO);
    return;
  }
  q->validated_until = vs->validated_until;
  q->pd.aged_rtt = vs->validation_rtt;
  n = q->neighbour;
  vl = lookup_virtual_link (&vs->pid);
  if (NULL == vl)
  {
    vl = GNUNET_new (struct VirtualLink);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Creating new virtual link %p to %s using direct neighbour!\n",
                vl,
                GNUNET_i2s (&vs->pid));
    vl->burst_addr = NULL;
    vl->confirmed = GNUNET_YES;
    vl->message_uuid_ctr =
      GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    vl->target = n->pid;
    vl->core_recv_window = RECV_WINDOW_SIZE;
    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
    /* What the peer will grant us in its very first FLOW_CONTROL anyway
       (@e incoming_fc_window_size plus what we have sent, i.e. nothing).
       Starting at zero instead means a link that is up, validated and
       working carries nothing at all until an FC round trip completes --
       and if the peer cannot answer, not ever. */
    vl->outbound_fc_window_size = DEFAULT_WINDOW_SIZE;
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_put (
                    links,
                    &vl->target,
                    vl,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    vl->n = n;
    n->vl = vl;
    q->idle = GNUNET_YES;
    vl->visibility_task =
      GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
    consider_sending_fc (vl);
    /* We lacked a confirmed connection to the target
       before, so tell CORE about it (finally!) */
    cores_send_connect_info (&n->pid);
    send_msg_from_cache (vl);
  }
  else
  {
    /* Link was already up, remember n is also now available and we are done */
    if (NULL == vl->n)
    {
      vl->n = n;
      n->vl = vl;
      if (GNUNET_YES == vl->confirmed)
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Virtual link to %s could now also use direct neighbour!\n",
                    GNUNET_i2s (&vs->pid));
    }
    else
    {
      GNUNET_assert (n == vl->n);
    }
    if (GNUNET_NO == vl->confirmed)
    {
      vl->confirmed = GNUNET_YES;
      q->idle = GNUNET_YES;
      vl->visibility_task =
        GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
      consider_sending_fc (vl);
      /* We lacked a confirmed connection to the target
         before, so tell CORE about it (finally!) */
      cores_send_connect_info (&n->pid);
      send_msg_from_cache (vl);
    }
  }
}

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(), find_queue_by_ip(), 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_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, VirtualLink::outbound_fc_window_size, peerstore, peerstore_store_validation_cb(), Neighbour::pid, ValidationState::pid, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_SignaturePurpose::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

im	the send message that was received

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

{
  struct TransportClient *tc = cls;
  struct Neighbour *n;
  struct CommunicatorMessageContext *cmc =
    GNUNET_new (struct CommunicatorMessageContext);
 
  cmc->tc = tc;
  cmc->im = *im;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received message with size %u and flow control id %" PRIu64
              " via communicator from peer %s\n",
              ntohs (im->header.size),
              im->fc_id,
              GNUNET_i2s (&im->sender));
  cmc->im.neighbour_sender = cmc->im.sender;
  /* A communicator got this straight from @a im->sender, so the queues to
     that neighbour demonstrably still work.  This is what #check_link_down()
     uses to bound how long a communicator that stopped working (without
     telling us) can keep a virtual link -- and CORE -- fooled. */
  if (NULL != (n = lookup_neighbour (&im->sender)))
    n->last_inbound = GNUNET_TIME_absolute_get ();
  cmc->mh = (const struct GNUNET_MessageHeader *) &im[1];
  demultiplex_with_cmc (cmc);
}

References demultiplex_with_cmc(), GNUNET_TRANSPORT_IncomingMessage::fc_id, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_TRANSPORT_IncomingMessage::header, CommunicatorMessageContext::im, Neighbour::last_inbound, lookup_neighbour(), 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

cls	a struct CommunicatorMessageContext
fc	the message that was received

Returns

GNUNET_YES if message is well-formed

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

{
  unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
  uint16_t msize = ntohs (fc->header.size);
  const char *tgnas;
  size_t avail;
  size_t off;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Flow control header size %u size of addresses %u number of addresses %u size of message struct %lu second struct %lu\n",
              ntohs (fc->header.size),
              ntohl (fc->size_of_addresses),
              ntohl (fc->number_of_addresses),
              sizeof(struct TransportFlowControlMessage),
              sizeof (struct TransportGlobalNattedAddress));
  if (0 == number_of_addresses)
    return GNUNET_OK;
  if (msize < sizeof(struct TransportFlowControlMessage))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  avail = msize - sizeof(struct TransportFlowControlMessage);
  tgnas = (const char *) &fc[1];
  off = 0;
  /* Validate EVERY entry: checking only the aggregate size lets a single
     entry claim a bogus address_length and send #handle_flow_control()
     out of bounds. */
  for (unsigned int i = 0; i < number_of_addresses; i++)
  {
    const struct TransportGlobalNattedAddress *tgna;
    size_t alen;
 
    if (avail - off < sizeof(struct TransportGlobalNattedAddress))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    tgna = (const struct TransportGlobalNattedAddress *) &tgnas[off];
    off += sizeof(struct TransportGlobalNattedAddress);
    alen = ntohl (tgna->address_length);
    if (avail - off < alen)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    off += alen;
  }
  return GNUNET_OK;
}

References TransportGlobalNattedAddress::address_length, 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 11684 of file gnunet-service-transport.c.

{
  struct VirtualLink *vl = cls;
  const char *slash;
  char *address_uri;
  char *prefix;
  char *uri_without_port;
 
  slash = strrchr (uri, '/');
  if ((NULL == slash) || (slash - uri < 2))
  {
    GNUNET_break_op (0);   /* @a uri comes from a remote HELLO */
    return;
  }
  prefix = GNUNET_strndup (uri, (slash - uri) - 2);
  slash++;
  GNUNET_asprintf (&address_uri,
                   "%s-%s",
                   prefix,
                   slash);
 
  uri_without_port = get_address_without_port (address_uri);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "iterate_address_start_burst %s %s %s %s\n",
              (NULL == uri_without_port) ? "<unparsable>" : uri_without_port,
              uri,
              address_uri,
              slash);
  GNUNET_free (vl->burst_addr);
  if ((NULL != uri_without_port) &&
      (0 == strcmp (uri_without_port, slash)))
    vl->burst_addr = GNUNET_strdup (uri_without_port);
 
  GNUNET_free (prefix);
  GNUNET_free (address_uri);
  GNUNET_free (uri_without_port);
}

References VirtualLink::burst_addr, get_address_without_port(), GNUNET_asprintf(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_strdup, 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 11726 of file gnunet-service-transport.c.

{
  struct GNUNET_StartBurstCls *sb_cls = cls;
  struct VirtualLink *vl = sb_cls->vl;
  const struct GNUNET_MessageHeader *hello;
  struct GNUNET_HELLO_Parser *parser;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    /* @a emsg comes with a NULL record, which means the iteration is over
       and PEERSTORE is releasing the context itself -- stopping it here as
       well would free it twice.  Just drop our handle. */
    vl->ic = NULL;
    free_burst_cls (sb_cls);
    return;
  }
  if (NULL == record)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Hello iteration end for %s\n",
                GNUNET_i2s (&vl->target));
    /* PEERSTORE destroys the context itself once it signals the end. */
    vl->ic = NULL;
    free_burst_cls (sb_cls);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "check_for_burst_address\n");
  /* @a hello was published by a remote peer, it may well be malformed. */
  hello = hello_from_record (record);
  if (NULL != hello)
  {
    parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
    if (NULL != parser)
    {
      GNUNET_HELLO_parser_iterate (parser,
                                   &iterate_address_start_burst,
                                   vl);
      GNUNET_HELLO_parser_free (parser);
    }
  }
 
  /* MUST clear @e ic: #GNUNET_PEERSTORE_iteration_stop() frees it, and
     #free_virtual_link() would otherwise stop it a second time. */
  if (NULL != vl->ic)
  {
    GNUNET_PEERSTORE_iteration_stop (vl->ic);
    vl->ic = NULL;
  }
  free_burst_cls (sb_cls);
}

References free_burst_cls(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_iterate(), GNUNET_i2s(), GNUNET_log, GNUNET_PEERSTORE_iteration_stop(), hello_from_record(), VirtualLink::ic, iterate_address_start_burst(), 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 11786 of file gnunet-service-transport.c.

{
  burst_running = GNUNET_NO;
}

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

{
  struct GNUNET_StartBurstCls *sb_cls = cls;
  struct VirtualLink *vl = sb_cls->vl;
  struct GNUNET_TRANSPORT_StartBurst *sb;
  struct GNUNET_MQ_Envelope *env;
  char *uri_without_port = vl->burst_addr;
 
  burst_task = NULL;
  burst_task_cls = NULL;
  if (NULL == uri_without_port)
  {
    /* Lost the address in the meantime, nothing to burst to. */
    free_burst_cls (sb_cls);
    return;
  }
  /*char buf[strlen (uri_without_port) + 1];
 
  GNUNET_memcpy (buf, uri_without_port,  strlen (uri_without_port));
  buf[strlen (uri_without_port)] = '\0';*/
  env =
    GNUNET_MQ_msg_extra (sb,
                         strlen (uri_without_port) + 1,
                         GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST);
  sb->rtt = GNUNET_TIME_relative_hton (sb_cls->rtt);
  sb->pid = vl->target;
  memcpy (&sb[1], uri_without_port, strlen (uri_without_port) + 1);
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_COMMUNICATOR != tc->type)
      continue;   /* MUST come first: the log below reads the union! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "iterate_address_start_burst client tc prefix %s\n",
                tc->details.communicator.address_prefix);
    if (GNUNET_YES == tc->details.communicator.can_burst)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "iterate_address_start_burst %s call %lu %u rtt %lu\n",
                  uri_without_port,
                  strlen (uri_without_port),
                  ntohs (sb->header.size),
                  (unsigned long) sb_cls->rtt.rel_value_us);
      GNUNET_MQ_send (tc->mq, env);
      env = NULL;   /* MQ took ownership */
      burst_running = GNUNET_YES;
      burst_timeout_task = GNUNET_SCHEDULER_add_delayed (
        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                       60),
        &burst_timeout,
        NULL);
      // TODO We need some algo to choose from available communicators. Can we run two bursts at once? Atm we only implemented udp burst.
      break;
    }
  }
  if (NULL != env)
    GNUNET_MQ_discard (env);
  free_burst_cls (sb_cls);
}

References VirtualLink::burst_addr, burst_running, burst_task, burst_task_cls, burst_timeout(), burst_timeout_task, clients_head, CT_COMMUNICATOR, env, free_burst_cls(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST, GNUNET_MQ_discard(), 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 11880 of file gnunet-service-transport.c.

{
  struct GNUNET_StartBurstCls *sb_cls = cls;
  struct VirtualLink *vl = sb_cls->vl;
 
  if (GNUNET_YES != use_burst)
  {
    /* MUST release: nobody else owns @a sb_cls, and #handle_flow_control()
       allocates one for every FLOW_CONTROL message we receive. */
    free_burst_cls (sb_cls);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "burst_task %p ready %s burst addr %s (%p)\n",
              burst_task,
              sb_cls->sync_ready ? "yes" : "no",
              vl->burst_addr,
              vl->burst_addr);
  if (NULL != burst_task && GNUNET_NO == sb_cls->sync_ready)
  {
    /* Cancel the pending burst.  Both closures (the scheduled task's and
       ours) are ours to release. */
    struct GNUNET_StartBurstCls *pending = burst_task_cls;
 
    GNUNET_SCHEDULER_cancel (burst_task);
    burst_task = NULL;
    burst_task_cls = NULL;
    if ((NULL != pending) && (pending != sb_cls))
      free_burst_cls (pending);
    free_burst_cls (sb_cls);
    return;
  }
  if (GNUNET_NO == burst_running && NULL != vl->burst_addr && NULL == burst_task
      )
  {
    burst_task = GNUNET_SCHEDULER_add_delayed (sb_cls->delay,
                                               &start_burst,
                                               sb_cls);
    burst_task_cls = sb_cls;
  }
  else if (NULL == vl->burst_addr)
  {
    if (NULL != vl->ic)
    {
      /* An address lookup is already running for this link; starting a
         second one would leak the first. */
      free_burst_cls (sb_cls);
      return;
    }
    vl->ic = GNUNET_PEERSTORE_iteration_start (peerstore,
                                               "peerstore",
                                               &vl->target,
                                               GNUNET_PEERSTORE_HELLO_KEY,
                                               check_for_burst_address,
                                               sb_cls);
  }
  else
  {
    /* A burst is already running or already scheduled; we have no use for
       this closure. */
    free_burst_cls (sb_cls);
  }
}

References VirtualLink::burst_addr, burst_running, burst_task, burst_task_cls, check_for_burst_address(), GNUNET_StartBurstCls::delay, free_burst_cls(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_iteration_start(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, VirtualLink::ic, peerstore, pending, 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:

unconfirmed_link_timeout()

static void unconfirmed_link_timeout ( void *  cls )

static

Discard a virtual link that only ever existed because some peer sent us a FLOW_CONTROL message and that never became confirmed.

Parameters

cls	the struct VirtualLink

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

{
  struct VirtualLink *vl = cls;
 
  vl->unconfirmed_timeout_task = NULL;
  if ((GNUNET_YES == vl->confirmed) ||
      (NULL != vl->n) ||
      (NULL != vl->dv))
    return;   /* got promoted in the meantime, its owner will clean up */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Discarding unconfirmed virtual link to %s\n",
              GNUNET_i2s (&vl->target));
  GNUNET_STATISTICS_update (GST_stats,
                            "# Unconfirmed virtual links timed out",
                            1,
                            GNUNET_NO);
  free_virtual_link (vl);
}

References VirtualLink::confirmed, VirtualLink::dv, free_virtual_link(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GST_stats, VirtualLink::n, VirtualLink::target, and VirtualLink::unconfirmed_timeout_task.

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

cls	a struct CommunicatorMessageContext (must call finish_cmc_handling() when done)
fc	the message that was received

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

{
  struct CommunicatorMessageContext *cmc = cls;
  struct VirtualLink *vl;
  struct GNUNET_TIME_Absolute q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  uint32_t seq;
  struct GNUNET_TIME_Absolute st;
  uint64_t os;
  uint64_t wnd;
  uint32_t random;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received FC from %s\n", GNUNET_i2s (&cmc->im.sender));
  vl = lookup_virtual_link (&cmc->im.sender);
  if (NULL == vl)
  {
    vl = GNUNET_new (struct VirtualLink);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No virtual link for %p FC creating new unconfirmed virtual link to %s!\n",
                vl,
                GNUNET_i2s (&cmc->im.sender));
    vl->burst_addr = NULL;
    vl->confirmed = GNUNET_NO;
    vl->message_uuid_ctr =
      GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    vl->target = cmc->im.sender;
    vl->core_recv_window = RECV_WINDOW_SIZE;
    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
    /* What the peer will grant us in its very first FLOW_CONTROL anyway
       (@e incoming_fc_window_size plus what we have sent, i.e. nothing).
       Starting at zero instead means a link that is up, validated and
       working carries nothing at all until an FC round trip completes --
       and if the peer cannot answer, not ever. */
    vl->outbound_fc_window_size = DEFAULT_WINDOW_SIZE;
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_put (
                    links,
                    &vl->target,
                    vl,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
    /* Nothing else owns this link yet, so it must reap itself if it never
       becomes confirmed -- otherwise any peer can make us allocate
       VirtualLinks without bound. */
    vl->unconfirmed_timeout_task =
      GNUNET_SCHEDULER_add_delayed (UNCONFIRMED_LINK_TIMEOUT,
                                    &unconfirmed_link_timeout,
                                    vl);
  }
  if (GNUNET_YES != vl->confirmed)
  {
    /* The peer flow-controls us, so it has a confirmed link to us -- but an
       unconfirmed link carries nothing and is never reported to CORE.  Only
       #handle_validation_response() breaks that tie, and nothing here used
       to ask for one, so the pair could sit one-way until the peer's own
       four hour revalidation came round. */
    try_to_bring_link_up (&cmc->im.sender);
  }
  if (NULL != vl->n)
  {
    for (struct Queue *q = vl->n->queue_head; NULL != q; q = q->next_neighbour)
      q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "remaining %lu timeout for neighbour %p\n",
              (unsigned long) GNUNET_TIME_absolute_get_remaining (q_timeout).
              rel_value_us,
              vl->n);
  if (NULL == vl->n ||
      0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
  {
    struct GNUNET_TIME_Relative rtt;
    struct GNUNET_BurstSync burst_sync;
    struct GNUNET_StartBurstCls *bcls;
 
    if (NULL != vl->sb_cls)
    {
      /* A burst attempt for this link is already in flight.  Allocating a
         second closure would orphan the first one: @e sb_cls is how
         #free_virtual_link() finds (and cancels) the pending #burst_task,
         and a peer that just keeps sending us FLOW_CONTROL messages would
         otherwise make us leak one closure per message. */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Burst attempt to %s already pending\n",
                  GNUNET_i2s (&vl->target));
    }
    else
    {
      bcls = GNUNET_new (struct GNUNET_StartBurstCls);
      bcls->vl = vl;
      vl->sb_cls = bcls;
      if (NULL != vl->dv)
        rtt = calculate_rtt (vl->dv);
      else
        rtt = GNUNET_TIME_UNIT_FOREVER_REL;
      burst_sync.rtt_average = fc->rtt;
      bcls->rtt = GNUNET_TIME_relative_ntoh (burst_sync.rtt_average);
      /* @e sync_ready of `struct GNUNET_BurstSync' is a host-order enum. */
      burst_sync.sync_ready =
        (enum GNUNET_GenericReturnValue) ntohl (fc->sync_ready);
 
      /* NOTE: #GNUNET_is_burst_ready() does NOT invoke the task unless both
         RTT estimates are known and close; #queue_burst() is thus not
         guaranteed to run, which is why @e sb_cls stays owned by @a vl. */
      GNUNET_is_burst_ready (rtt,
                             &burst_sync,
                             &queue_burst,
                             bcls);
    }
  }
  if (0 != ntohl (fc->number_of_addresses))
  {
    unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
    const char *tgnas;
    unsigned int off = 0;
 
    tgnas = (const char *) &fc[1];
 
    for (unsigned int i = 0; i < number_of_addresses; i++)
    {
      struct TransportGlobalNattedAddress *tgna;
      char *addr;
      uint32_t address_length;
 
      tgna = (struct TransportGlobalNattedAddress*) &tgnas[off];
      addr = (char *) &tgna[1];
      address_length = ntohl (tgna->address_length);
      off += sizeof(struct TransportGlobalNattedAddress) + address_length;
 
      /* NOTE: the address is NOT 0-terminated (it comes straight off the
         wire), it must be printed with an explicit precision. */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "received address %.*s length %u\n",
                  (int) address_length,
                  addr,
                  address_length);
 
      if (NULL != nh)
        GNUNET_NAT_add_global_address (nh, addr, ntohl (tgna->address_length));
    }
  }
  st = GNUNET_TIME_absolute_ntoh (fc->sender_time);
  if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "FC dropped: Message out of order\n");
    /* out of order, drop */
    GNUNET_STATISTICS_update (GST_stats,
                              "# FC dropped: message out of order",
                              1,
                              GNUNET_NO);
    finish_cmc_handling (cmc);
    return;
  }
  seq = ntohl (fc->seq);
  if (seq < vl->last_fc_seq)
  {
    /* Wrap-around/reset of other peer; start all counters from zero */
    vl->outbound_fc_window_size_used = 0;
  }
  vl->last_fc_seq = seq;
  vl->last_fc_timestamp = st;
  /* The peer is answering, so the backoff in #consider_sending_fc() starts
     over: @e fc_retransmit_count counts *unanswered* rounds. */
  vl->fc_retransmit_count = 0;
  vl->outbound_fc_window_size = GNUNET_ntohll (fc->inbound_window_size);
  os = GNUNET_ntohll (fc->outbound_sent);
  vl->incoming_fc_window_size_loss =
    (int64_t) (os - vl->incoming_fc_window_size_used);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received FC from %s, seq %u, new window %llu (loss at %lld)\n",
              GNUNET_i2s (&vl->target),
              (unsigned int) seq,
              (unsigned long long) vl->outbound_fc_window_size,
              (long long) vl->incoming_fc_window_size_loss);
  wnd = GNUNET_ntohll (fc->outbound_window_size);
  random = GNUNET_CRYPTO_random_u32 (UINT32_MAX);
  /* NOTE: this must NOT be restricted to a confirmed link.  @e
     outbound_fc_window_size starts at zero and is raised *only* here, from
     the peer's FC.  So a peer whose link to us is confirmed while ours to it
     is not cannot send us a single byte until we answer -- and it is exactly
     that peer that keeps asking.  Staying quiet deadlocks the pair: it shows
     an established virtual link with messages pending forever, we show none,
     and CORE never completes its handshake in either direction. */
  if ((wnd < vl->incoming_fc_window_size
       + vl->incoming_fc_window_size_used
       + vl->incoming_fc_window_size_loss) ||
      (vl->last_outbound_window_size_received != wnd) ||
      (0 == random % FC_NO_CHANGE_REPLY_PROBABILITY))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "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",
                (unsigned long long) wnd,
                (unsigned long long) vl->incoming_fc_window_size,
                (unsigned long long) vl->last_outbound_window_size_received,
                random % FC_NO_CHANGE_REPLY_PROBABILITY);
    consider_sending_fc (vl);
  }
  if ((wnd == vl->incoming_fc_window_size
       + vl->incoming_fc_window_size_used
       + vl->incoming_fc_window_size_loss) &&
      (vl->last_outbound_window_size_received == wnd))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Slowing FC transmission to %s to keepalive rate: peer is current at window %llu\n",
                GNUNET_i2s (&vl->target),
                (unsigned long long) wnd);
    /* NOTE: this used to also require @e fc_retransmit_task to be non-NULL
       and did nothing at all otherwise -- so a link whose chain had ended
       (see #consider_sending_fc()) could never pick the keepalive back up,
       even though the peer was demonstrably still talking to us. */
    if (NULL != vl->fc_retransmit_task)
      GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
    vl->fc_retransmit_count = 0;
    /* Drop to the keepalive rate rather than stopping outright.  There is
       nothing left to retransmit -- but if we go completely quiet, and the
       peer does the same for the same reason, then neither end sees any
       traffic and #check_link_down() tears down a perfectly healthy link
       after #NEIGHBOUR_LIVENESS_TIMEOUT.  One tiny FC message every
       #FC_KEEPALIVE_INTERVAL is what keeps @e last_inbound moving on the
       other side (and, via their reply, on ours). */
    vl->fc_retransmit_task =
      GNUNET_SCHEDULER_add_delayed (FC_KEEPALIVE_INTERVAL,
                                    &task_consider_sending_fc,
                                    vl);
  }
  vl->last_outbound_window_size_received = wnd;
  /* FC window likely increased, check transmission possibilities! */
  check_vl_transmission (vl);
  finish_cmc_handling (cmc);
}

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_KEEPALIVE_INTERVAL, 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_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_add_delayed(), 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, 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, task_consider_sending_fc(), try_to_bring_link_up(), UNCONFIRMED_LINK_TIMEOUT, unconfirmed_link_timeout(), VirtualLink::unconfirmed_timeout_task, 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

cls	the client
aqm	the send message that was sent

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

{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_MQ_check_zero_termination (aqm);
  return GNUNET_OK;
}

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

pm	pending message to generate UUID for.

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

{
  if (pm->msg_uuid_set)
    return;
  pm->msg_uuid.uuid = pm->vl->message_uuid_ctr++;
  pm->msg_uuid_set = GNUNET_YES;
}

References GNUNET_YES, VirtualLink::message_uuid_ctr, PendingMessage::msg_uuid, PendingMessage::msg_uuid_set, MessageUUIDP::uuid, and PendingMessage::vl.

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

queue	queue the pm will be sent over
dvh	path the message will take, may be NULL
pm	the pending message for transmission

Returns

corresponding fresh pending acknowledgement

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

{
  struct PendingAcknowledgement *pa;
 
  pa = GNUNET_new (struct PendingAcknowledgement);
  pa->queue = queue;
  pa->dvh = dvh;
  pa->pm = pm;
  do
  {
    GNUNET_CRYPTO_random_block (&pa->ack_uuid,
                                sizeof(pa->ack_uuid));
  }
  while (GNUNET_YES != GNUNET_CONTAINER_multiuuidmap_put (
           pending_acks,
           &pa->ack_uuid.value,
           pa,
           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  GNUNET_CONTAINER_MDLL_insert (queue, queue->pa_head, queue->pa_tail, pa);
  GNUNET_CONTAINER_MDLL_insert (pm, pm->pa_head, pm->pa_tail, pa);
  if (NULL != dvh)
    GNUNET_CONTAINER_MDLL_insert (dvh, dvh->pa_head, dvh->pa_tail, pa);
  pa->transmission_time = GNUNET_TIME_absolute_get ();
  pa->message_size = pm->bytes_msg;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Waiting for ACKnowledgment `%s' for <%" PRIu64 ">\n",
              GNUNET_uuid2s (&pa->ack_uuid.value),
              pm->logging_uuid);
  return pa;
}

References PendingAcknowledgement::ack_uuid, PendingMessage::bytes_msg, PendingAcknowledgement::dvh, GNUNET_CONTAINER_MDLL_insert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multiuuidmap_put(), GNUNET_CRYPTO_random_block(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_TIME_absolute_get(), GNUNET_uuid2s(), GNUNET_YES, PendingMessage::logging_uuid, PendingAcknowledgement::message_size, DistanceVectorHop::pa_head, PendingMessage::pa_head, DistanceVectorHop::pa_tail, PendingMessage::pa_tail, pending_acks, PendingAcknowledgement::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

queue	which queue to fragment for
dvh	path the message will take, or NULL
pm	pending message to fragment for transmission

Returns

new message to transmit

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

{
  struct PendingAcknowledgement *pa;
  struct PendingMessage *ff;
  uint16_t mtu;
  uint16_t msize;
 
  mtu = (UINT16_MAX == queue->mtu)
        ? UINT16_MAX - sizeof(struct GNUNET_TRANSPORT_SendMessageTo)
        : queue->mtu;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Fragmenting message <%" PRIu64
              "> with size %u to %s for MTU %u\n",
              pm->logging_uuid,
              pm->bytes_msg,
              GNUNET_i2s (&pm->vl->target),
              (unsigned int) mtu);
  set_pending_message_uuid (pm);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Fragmenting message %" PRIu64 " <%" PRIu64
              "> with size %u to %s for MTU %u\n",
              pm->msg_uuid.uuid,
              pm->logging_uuid,
              pm->bytes_msg,
              GNUNET_i2s (&pm->vl->target),
              (unsigned int) mtu);
 
  /* This invariant is established in #handle_add_queue_message() */
  GNUNET_assert (mtu > sizeof(struct TransportFragmentBoxMessage));
 
  /* select fragment for transmission, descending the tree if it has
     been expanded until we are at a leaf or at a fragment that is small
     enough
   */
  ff = pm;
  msize = ff->bytes_msg;
 
  while (((ff->bytes_msg > mtu) || (pm == ff)) &&
         (ff->frag_off == msize) && (NULL != ff->head_frag))
  {
    ff = ff->head_frag;   /* descent into fragmented fragments */
    msize = ff->bytes_msg - sizeof(struct TransportFragmentBoxMessage);
  }
 
  if (((ff->bytes_msg > mtu) || (pm == ff)) && (ff->frag_off < msize))
  {
    /* Did not yet calculate all fragments, calculate next fragment */
    struct PendingMessage *frag;
    struct TransportFragmentBoxMessage tfb;
    const char *orig;
    char *msg;
    uint16_t fragmax;
    uint16_t fragsize;
    uint16_t msize_ff;
    uint16_t xoff = 0;
    pm->frag_count++;
 
    orig = (const char *) &ff[1];
    msize_ff = ff->bytes_msg;
    if (pm != ff)
    {
      const struct TransportFragmentBoxMessage *tfbo;
 
      tfbo = (const struct TransportFragmentBoxMessage *) orig;
      orig += sizeof(struct TransportFragmentBoxMessage);
      msize_ff -= sizeof(struct TransportFragmentBoxMessage);
      xoff = ntohs (tfbo->frag_off);
    }
    fragmax = mtu - sizeof(struct TransportFragmentBoxMessage);
    fragsize = GNUNET_MIN (msize_ff - ff->frag_off, fragmax);
    frag =
      GNUNET_malloc (sizeof(struct PendingMessage)
                     + sizeof(struct TransportFragmentBoxMessage) + fragsize);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "3 created pm %p from pm %p storing vl %p from pm %p\n",
                frag,
                ff,
                pm->vl,
                pm);
    frag->logging_uuid = logging_uuid_gen++;
    frag->vl = pm->vl;
    frag->frag_parent = ff;
    frag->timeout = pm->timeout;
    frag->bytes_msg = sizeof(struct TransportFragmentBoxMessage) + fragsize;
    frag->pmt = PMT_FRAGMENT_BOX;
    msg = (char *) &frag[1];
    tfb.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT);
    tfb.header.size =
      htons (sizeof(struct TransportFragmentBoxMessage) + fragsize);
    pa = prepare_pending_acknowledgement (queue, dvh, frag);
    tfb.ack_uuid = pa->ack_uuid;
    tfb.msg_uuid = pm->msg_uuid;
    tfb.frag_off = htons (ff->frag_off + xoff);
    tfb.msg_size = htons (pm->bytes_msg);
    memcpy (msg, &tfb, sizeof(tfb));
    memcpy (&msg[sizeof(tfb)], &orig[ff->frag_off], fragsize);
    GNUNET_CONTAINER_MDLL_insert (frag, ff->head_frag,
                                  ff->tail_frag, frag);
    ff->frag_off += fragsize;
    ff = frag;
  }
 
  if (pm == ff)
  {
    /* Neither the descent nor the branch above moved us off @a pm, so there
       is no fragment to send: @e head_frag is empty *and* @e frag_off says
       everything was already cut.  completed_pending_message() leaves
       exactly that state behind when the last outstanding fragment is
       acknowledged but its condition for finishing the root does not hold
       (@e frag_off having been advanced past the boxed payload size, or the
       root being a reliability box).  The rotate below then dereferences
       @e frag_parent, which is NULL for the message on @e pending_msg_head.
 
       Report "nothing to fragment" instead; the caller reschedules. */
    GNUNET_break (0);
    return NULL;
  }
  /* Move head to the tail and return it */
  GNUNET_CONTAINER_MDLL_remove (frag,
                                ff->frag_parent->head_frag,
                                ff->frag_parent->tail_frag,
                                ff);
  GNUNET_CONTAINER_MDLL_insert_tail (frag,
                                     ff->frag_parent->head_frag,
                                     ff->frag_parent->tail_frag,
                                     ff);
 
  return ff;
}

References TransportFragmentBoxMessage::ack_uuid, PendingAcknowledgement::ack_uuid, PendingMessage::bytes_msg, PendingMessage::frag_count, TransportFragmentBoxMessage::frag_off, PendingMessage::frag_off, PendingMessage::frag_parent, GNUNET_assert, GNUNET_break, 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, PendingMessage::msg_uuid, PendingMessage::pmt, PMT_FRAGMENT_BOX, prepare_pending_acknowledgement(), queue(), set_pending_message_uuid(), GNUNET_MessageHeader::size, PendingMessage::tail_frag, VirtualLink::target, PendingMessage::timeout, GNUNET_MessageHeader::type, MessageUUIDP::uuid, 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

queue	which queue to prepare transmission for
dvh	path the message will take, or NULL
pm	pending message to box for transmission over unreliabile queue

Returns

new message to transmit

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

{
  struct TransportReliabilityBoxMessage rbox;
  struct PendingAcknowledgement *pa;
  struct PendingMessage *bpm;
  char *msg;
 
  if ((PMT_CORE != pm->pmt) && (PMT_DV_BOX != pm->pmt))
    return pm; /* already fragmented or reliability boxed, or control message:
                  do nothing */
  if (NULL != pm->bpm)
    return pm->bpm; /* already computed earlier: do nothing */
  // TODO I guess we do not need this assertion. We might have a DLL with
  // fragments, because the MTU changed, and we do not need to fragment anymore.
  // But we should keep the fragments until message was completed, because
  // the MTU might change again.
  // GNUNET_assert (NULL == pm->head_frag);
  if (pm->bytes_msg + sizeof(rbox) > UINT16_MAX)
  {
    /* failed hard */
    GNUNET_break (0);
    client_send_response (pm);
    return NULL;
  }
 
  pa = prepare_pending_acknowledgement (queue, dvh, pm);
 
  bpm = GNUNET_malloc (sizeof(struct PendingMessage) + sizeof(rbox)
                       + pm->bytes_msg);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "4 created pm %p storing vl %p from pm %p\n",
              bpm,
              pm->vl,
              pm);
  bpm->logging_uuid = logging_uuid_gen++;
  bpm->vl = pm->vl;
  bpm->frag_parent = pm;
  // Why was this needed?
  // GNUNET_CONTAINER_MDLL_insert (frag, pm->head_frag, pm->tail_frag, bpm);
  bpm->timeout = pm->timeout;
  bpm->pmt = PMT_RELIABILITY_BOX;
  bpm->bytes_msg = pm->bytes_msg + sizeof(rbox);
  set_pending_message_uuid (bpm);
  rbox.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX);
  rbox.header.size = htons (sizeof(rbox) + pm->bytes_msg);
  rbox.ack_countdown = htonl (0);  // FIXME: implement ACK countdown support
 
  rbox.ack_uuid = pa->ack_uuid;
  msg = (char *) &bpm[1];
  memcpy (msg, &rbox, sizeof(rbox));
  memcpy (&msg[sizeof(rbox)], &pm[1], pm->bytes_msg);
  pm->bpm = bpm;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Preparing reliability box for message <%" PRIu64
              "> of size %d (%d) to %s on queue %s\n",
              pm->logging_uuid,
              pm->bytes_msg,
              ntohs (((const struct GNUNET_MessageHeader *) &pm[1])->size),
              GNUNET_i2s (&pm->vl->target),
              queue->address);
  return bpm;
}

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, PendingMessage::pmt, PMT_CORE, PMT_DV_BOX, PMT_RELIABILITY_BOX, prepare_pending_acknowledgement(), queue(), set_pending_message_uuid(), GNUNET_MessageHeader::size, size, VirtualLink::target, 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 12620 of file gnunet-service-transport.c.

{
  struct VirtualLink *vl = pm->vl;
  struct PendingMessage *pos;
 
  /* Only a message without a parent is on vl->pending_msg_head; anything
     else is not ours to reorder and MDLL_remove() would abort on it. */
  if ((NULL == vl) ||
      (NULL != pm->frag_parent) ||
      ((NULL == pm->prev_vl) && (vl->pending_msg_head != pm)))
  {
    GNUNET_break (0);
    return;
  }
  /* re-insert sort in neighbour list */
  GNUNET_CONTAINER_MDLL_remove (vl,
                                vl->pending_msg_head,
                                vl->pending_msg_tail,
                                pm);
  pos = vl->pending_msg_tail;
  while ((NULL != pos) &&
         (next_attempt.abs_value_us > pos->next_attempt.abs_value_us))
    pos = pos->prev_vl;
  GNUNET_CONTAINER_MDLL_insert_after (vl,
                                      vl->pending_msg_head,
                                      vl->pending_msg_tail,
                                      pos,
                                      pm);
}

References GNUNET_TIME_Absolute::abs_value_us, PendingMessage::frag_parent, GNUNET_break, GNUNET_CONTAINER_MDLL_insert_after, GNUNET_CONTAINER_MDLL_remove, PendingMessage::next_attempt, VirtualLink::pending_msg_head, VirtualLink::pending_msg_tail, 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 12653 of file gnunet-service-transport.c.

{
  struct PendingMessage *pos;
  /* MUST be initialised: for a leaf the loop below never runs */
  enum GNUNET_GenericReturnValue frags_in_flight = GNUNET_NO;
 
  pos = pm->head_frag;
  while (NULL != pos)
  {
    if (pos->frags_in_flight_round == pm->frags_in_flight_round ||
        GNUNET_NO == check_next_attempt_tree (pos, root))
      frags_in_flight = GNUNET_NO;
    else
    {
      frags_in_flight = GNUNET_YES;
      break;
    }
    pos = pos->next_frag;
  }
 
  return frags_in_flight;
}

References check_next_attempt_tree(), PendingMessage::frags_in_flight, PendingMessage::frags_in_flight_round, GNUNET_NO, GNUNET_YES, PendingMessage::head_frag, and PendingMessage::next_frag.

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

{
  struct PendingMessage *pos;
 
  pos = pm->head_frag;
  while (NULL != pos)
  {
    pos->frags_in_flight_round = pm->frags_in_flight_round;
    harmonize_flight_round (pos);
    pos = pos->next_frag;
  }
}

References PendingMessage::frags_in_flight_round, harmonize_flight_round(), PendingMessage::head_frag, and PendingMessage::next_frag.

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

pm	a pending message to update
next_attempt	timestamp to use

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

{
  if (NULL == pm->frag_parent)
  {
    pm->next_attempt = next_attempt;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Next attempt for message <%" PRIu64 "> set to %" PRIu64 "\n",
                pm->logging_uuid,
                next_attempt.abs_value_us);
    reorder_root_pm (pm, next_attempt);
  }
  else if ((PMT_RELIABILITY_BOX == pm->pmt) || (PMT_DV_BOX == pm->pmt))// || (PMT_FRAGMENT_BOX == pm->pmt))
  {
    struct PendingMessage *root = pm->frag_parent;
 
    while (NULL != root->frag_parent)
      root = root->frag_parent;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Next attempt for root message <%" PRIu64 "> set to %s\n",
                root->logging_uuid,
                GNUNET_STRINGS_absolute_time_to_string (next_attempt));
    root->next_attempt = next_attempt;
    reorder_root_pm (root, next_attempt);
  }
  else
  {
    struct PendingMessage *root = pm->frag_parent;
 
    while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
      root = root->frag_parent;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "frag_count next attempt %u\n",
                root->frag_count);
 
    if (GNUNET_NO == root->frags_in_flight)
    {
      root->next_attempt = next_attempt;
      harmonize_flight_round (root);
      root->frags_in_flight_round++;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Next attempt for fragmented message <%" PRIu64 "> (<%" PRIu64
                  ">)set to %" PRIu64 "\n",
                  pm->logging_uuid,
                  root->logging_uuid,
                  next_attempt.abs_value_us);
    }
 
    pm->next_attempt = root->next_attempt;
    pm->frags_in_flight_round = root->frags_in_flight_round;
    harmonize_flight_round (pm);
 
    if (root->bytes_msg == root->frag_off)
      root->frags_in_flight = check_next_attempt_tree (root, root);
    else
      root->frags_in_flight = GNUNET_YES;
 
    if (GNUNET_NO == root->frags_in_flight)
    {
      /* `root' deliberately stops at a DV box, which is itself a child of
         the message on vl->pending_msg_head.  Walk the rest of the way for
         the reorder: only the parentless message is on that list. */
      struct PendingMessage *vl_root = root;
 
      while (NULL != vl_root->frag_parent)
        vl_root = vl_root->frag_parent;
      vl_root->next_attempt = root->next_attempt;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "We have no fragments in flight for message %" PRIu64
                  ", reorder root %" PRIu64 "! Next attempt is %" PRIu64 "\n",
                  root->logging_uuid,
                  vl_root->logging_uuid,
                  vl_root->next_attempt.abs_value_us);
      reorder_root_pm (vl_root, vl_root->next_attempt);
    }
    else
    {
      double factor = ((double) root->frag_count - 1)
                      / (double) root->frag_count;
      struct GNUNET_TIME_Relative s1;
      struct GNUNET_TIME_Relative s2;
      struct GNUNET_TIME_Relative plus_mean =
        GNUNET_TIME_absolute_get_remaining (root->next_attempt);
      struct GNUNET_TIME_Relative plus = GNUNET_TIME_absolute_get_remaining (
        next_attempt);
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "frag_count %u after factor\n",
                  root->frag_count);
      s1 = GNUNET_TIME_relative_multiply_double (plus_mean,
                                                 factor);
      s2 = GNUNET_TIME_relative_divide (plus,
                                        root->frag_count);
      plus_mean = GNUNET_TIME_relative_add (s1, s2);
      root->next_attempt = GNUNET_TIME_relative_to_absolute (plus_mean);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "We have fragments in flight for message %" PRIu64
                  ", do not reorder root! Actual next attempt %" PRIu64 "\n",
                  root->logging_uuid,
                  root->next_attempt.abs_value_us);
    }
  }
}

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, 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]	sc	best message so far (NULL for none), plus scoring data
	queue	the queue that will be used for transmission
	vl	the virtual link providing the messages
	dvh	path we are currently considering, or NULL for none
	overhead	number of bytes of overhead to be expected from DV encapsulation (0 for without DV)

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

{
  struct GNUNET_TIME_Absolute now;
 
  now = GNUNET_TIME_absolute_get ();
  /* NOTE: @a sc accumulates across calls -- #transmit_on_queue() zeroes it
     once and then runs us for the direct link and for every DV hop in turn.
     Clearing the verdict here made each call discard what the previous ones
     found, so a message that was too early on the direct link was forgotten
     as soon as one DV hop had nothing to offer, and nothing rescheduled the
     queue at all. */
  for (struct PendingMessage *pos = vl->pending_msg_head; NULL != pos;
       pos = pos->next_vl)
  {
    size_t real_overhead = overhead;
    int frag;
    int relb;
 
    if ((NULL != dvh) && (PMT_DV_BOX == pos->pmt))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "DV messages must not be DV-routed to next hop!\n");
      continue;   /* DV messages must not be DV-routed to next hop! */
    }
    if (pos->next_attempt.abs_value_us > now.abs_value_us)
    {
      if (GNUNET_YES == pos->frags_in_flight)
      {
        sc->frags_in_flight = GNUNET_YES;
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Fragments in flight for message %" PRIu64 "\n",
                    pos->logging_uuid);
      }
      else
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Maybe too early, because message are sorted by next_attempt, if there are no fragments in flight.Checked message %"
                    PRIu64 "\n",
                    pos->logging_uuid);
        /* The *earliest* deadline is the one to come back for: @e
           pending_msg_head is sorted by @e next_attempt, so overwriting
           this on every iteration left the largest delay of the whole
           list -- the queue then slept past every message but the last
           one.  Across the calls for the direct link and each DV hop the
           same argument applies, hence the min() rather than an
           assignment. */
        sc->to_early_retry_delay =
          (GNUNET_YES == sc->to_early)
          ? GNUNET_TIME_relative_min (sc->to_early_retry_delay,
                                      GNUNET_TIME_absolute_get_remaining (
                                        pos->next_attempt))
          : GNUNET_TIME_absolute_get_remaining (pos->next_attempt);
        sc->to_early = GNUNET_YES;
        continue;
      }
      // break;   /* too early for all messages, they are sorted by next_attempt */
    }
    if (NULL != pos->qe)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "not eligible\n");
      continue;   /* not eligible */
    }
    sc->consideration_counter++;
    /* determine if we have to fragment, if so add fragmentation
       overhead! */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "check %" PRIu64 " for sc->best\n",
                pos->logging_uuid);
    frag = GNUNET_NO;
    if (((0 != queue->mtu) &&
         (pos->bytes_msg + real_overhead > queue->mtu)) ||
        (pos->bytes_msg > UINT16_MAX - sizeof(struct
                                              GNUNET_TRANSPORT_SendMessageTo))
        ||
        (NULL != pos->head_frag /* fragments already exist, should
                                     respect that even if MTU is UINT16_MAX for
                                     this queue */))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "fragment msg with size %u, realoverhead is %lu\n",
                  pos->bytes_msg,
                  real_overhead);
      frag = GNUNET_YES;
      if (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc)
      {
        /* FIXME-FRAG-REL-UUID: we could use an optimized, shorter fragmentation
           header without the ACK UUID when using a *reliable* channel! */
      }
      real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
    }
    /* determine if we have to reliability-box, if so add reliability box
       overhead */
    relb = GNUNET_NO;
    if ((GNUNET_NO == frag) &&
        (0 == (pos->prefs & GNUNET_MQ_PREF_UNRELIABLE)) &&
        (GNUNET_TRANSPORT_CC_RELIABLE != queue->tc->details.communicator.cc))
    {
      real_overhead += sizeof(struct TransportReliabilityBoxMessage);
 
      if ((0 != queue->mtu) && (pos->bytes_msg + real_overhead > queue->mtu))
      {
        frag = GNUNET_YES;
        real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
      }
      else
      {
        relb = GNUNET_YES;
      }
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Create reliability box of msg with size %u, realoverhead is %lu %u %u %u\n",
                  pos->bytes_msg,
                  real_overhead,
                  queue->mtu,
                  frag,
                  relb);
    }
 
    /* Finally, compare to existing 'best' in sc to see if this 'pos' pending
       message would beat it! */
    if (GNUNET_NO == sc->frags_in_flight && NULL != sc->best)
    {
      /* CHECK if pos fits queue BETTER (=smaller) than pm, if not: continue;
         OPTIMIZE-ME: This is a heuristic, which so far has NOT been
         experimentally validated. There may be some huge potential for
         improvement here. Also, we right now only compare how well the
         given message fits _this_ queue, and do not consider how well other
         queues might suit the message. Taking other queues into consideration
         may further improve the result, but could also be expensive
         in terms of CPU time.  */
      long long sc_score = sc->frag * 40 + sc->relb * 20 + sc->real_overhead;
      long long pm_score = frag * 40 + relb * 20 + real_overhead;
      long long time_delta =
        (sc->best->next_attempt.abs_value_us - pos->next_attempt.abs_value_us)
        / 1000LL;
 
      /* "time_delta" considers which message has been 'ready' for transmission
         for longer, if a message has a preference for low latency, increase
         the weight of the time_delta by 10x if it is favorable for that message */
      if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
          (0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)))
        time_delta *= 10;     /* increase weight (always, both are low latency) */
      else if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
               (time_delta > 0))
        time_delta *= 10;     /* increase weight, favors 'pos', which is low latency */
      else if ((0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
               (time_delta < 0))
        time_delta *= 10;     /* increase weight, favors 'sc->best', which is low latency */
      if (0 != queue->mtu)
      {
        /* Grant bonus if we are below MTU, larger bonus the closer we will
           be to the MTU */
        if (queue->mtu > sc->real_overhead + sc->best->bytes_msg)
          sc_score -= queue->mtu - (sc->real_overhead + sc->best->bytes_msg);
        if (queue->mtu > real_overhead + pos->bytes_msg)
          pm_score -= queue->mtu - (real_overhead + pos->bytes_msg);
      }
      if (sc_score + time_delta > pm_score)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "sc_score of %" PRIu64 " larger, keep sc->best %" PRIu64
                    "\n",
                    pos->logging_uuid,
                    sc->best->logging_uuid);
        continue;     /* sc_score larger, keep sc->best */
      }
    }
    sc->best = pos;
    sc->dvh = dvh;
    sc->frag = frag;
    sc->relb = relb;
    sc->real_overhead = real_overhead;
  }
}

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_TIME_relative_min(), GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_YES, 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

cls	a struct PendingMessageScoreContext
next_hop	next hop of the DV path
hdr	encapsulated message, technically a struct TransportDVBoxMessage
options	options of the original message

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

{
  struct PendingMessageScoreContext *sc = cls;
  struct PendingMessage *pm = sc->best;
  struct PendingMessage *bpm;
  uint16_t bsize = ntohs (hdr->size);
 
  GNUNET_assert (NULL == pm->bpm);
  bpm = GNUNET_malloc (sizeof(struct PendingMessage) + bsize);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "5 created pm %p storing vl %p from pm %p\n",
              bpm,
              pm->vl,
              pm);
  bpm->logging_uuid = logging_uuid_gen++;
  bpm->pmt = PMT_DV_BOX;
  bpm->vl = pm->vl;
  bpm->timeout = pm->timeout;
  bpm->bytes_msg = bsize;
  bpm->frag_parent = pm;
  set_pending_message_uuid (bpm);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating DV Box %" PRIu64 " for original message %" PRIu64
              " (next hop is %s)\n",
              bpm->logging_uuid,
              pm->logging_uuid,
              GNUNET_i2s (&next_hop->pid));
  memcpy (&bpm[1], hdr, bsize);
  pm->bpm = bpm;
}

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, 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

cls	the client
dqm	the send message that was sent

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

{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    struct Neighbour *neighbour = queue->neighbour;
 
    if ((ntohl (dqm->qid) != queue->qid) ||
        (0 != GNUNET_memcmp (&dqm->receiver, &neighbour->pid)))
      continue;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Dropped queue %s to peer %s\n",
                queue->address,
                GNUNET_i2s (&neighbour->pid));
    free_queue (queue);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  /* Not finding the queue is a race, not a protocol violation: we may have
     freed it ourselves already, or the communicator may be tearing down a
     queue we never fully learned about.  Do NOT drop the client over it --
     that runs #client_disconnect_cb(), which frees *every* queue this
     communicator owns, so one stale QUEUE_TEARDOWN would disconnect us from
     every peer it serves at once.  Compare #handle_send_message_ack(), which
     tolerates the same lookup miss. */
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "QUEUE_TEARDOWN for unknown queue QID %u to peer %s ignored\n",
              ntohl (dqm->qid),
              GNUNET_i2s (&dqm->receiver));
  GNUNET_STATISTICS_update (GST_stats,
                            "# QUEUE_TEARDOWN dropped: queue unknown",
                            1,
                            GNUNET_NO);
  GNUNET_SERVICE_client_continue (tc->client);
}

References CT_COMMUNICATOR, free_queue(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GST_stats, 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

cls	the client
sma	the send message that was sent

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

{
  struct TransportClient *tc = cls;
  struct QueueEntry *qe;
  struct Queue *failed_queue = NULL;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
 
  /* find our queue entry matching the ACK */
  qe = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Looking for queue for PID %s\n",
              GNUNET_i2s (&sma->receiver));
  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
       queue = queue->next_client)
  {
    if (0 != GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver))
      continue;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Found PID %s\n",
                GNUNET_i2s (&queue->neighbour->pid));
 
 
    for (struct QueueEntry *qep = queue->queue_head; NULL != qep;
         qep = qep->next)
    {
      if (qep->mid != GNUNET_ntohll (sma->mid) || queue->qid != ntohl (
            sma->qid))
        continue;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "QueueEntry MID: %" PRIu64 " on queue QID: %u, Ack MID: %"
                  PRIu64 " Ack QID %u\n",
                  qep->mid,
                  queue->qid,
                  GNUNET_ntohll (sma->mid),
                  ntohl (sma->qid));
      qe = qep;
      if ((NULL != qe->pm) && (qe->pm->qe != qe))
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "For pending message %" PRIu64 " we had retransmissions.\n",
                    qe->pm->logging_uuid);
      break;
    }
  }
  if (GNUNET_OK != (int) ntohl (sma->status))
  {
    /* The communicator could not hand the message to the peer.  The only
       thing that produces this today is #handle_send_msg()'s "queue no
       longer exists" branch in `transport_api_communication.c', i.e. the
       communicator has already torn the queue down on its side and the
       QUEUE_TEARDOWN is merely still in flight (or was lost).
 
       Ignoring the status, as we used to, makes this self-sustaining:
       #free_queue_entry() releases the pending message and immediately
       reschedules transmission, #transmit_on_queue() picks the very same
       queue again -- transport still has it -- and we get another failure.
       Every round adds an envelope to the client MQ that is already
       congested, which is what shows up at the other end as
 
         communicator INFO Transmission failed, queue no longer exists.
 
       repeating at scheduler speed, and (because the service is busy
       servicing that loop) as
 
         communicator WARNING Dropping message: transport is too slow,
                              queue length N exceeded
 
       on every *other* communicator.  Treat the failure as the queue
       teardown it is and stop selecting this queue. */
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Communicator could not send MID %" PRIu64
                " on QID %u to %s; dropping that queue\n",
                GNUNET_ntohll (sma->mid),
                ntohl (sma->qid),
                GNUNET_i2s (&sma->receiver));
    GNUNET_STATISTICS_update (GST_stats,
                              "# queues dropped (communicator send failed)",
                              1,
                              GNUNET_NO);
    if (NULL != qe)
      failed_queue = qe->queue;
    else
      for (struct Queue *queue = tc->details.communicator.queue_head;
           NULL != queue;
           queue = queue->next_client)
        if ((ntohl (sma->qid) == queue->qid) &&
            (0 == GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver)))
        {
          failed_queue = queue;
          break;
        }
    if (NULL != failed_queue)
    {
      /* #free_queue() releases every `struct QueueEntry' still on it --
         including @a qe -- and detaches their pending messages, so they are
         retried on whatever other queue this neighbour has. */
      free_queue (failed_queue);
      GNUNET_SERVICE_client_continue (tc->client);
      return;
    }
  }
  if (NULL == qe)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No QueueEntry found for Ack MID %" PRIu64 " QID: %u\n",
                GNUNET_ntohll (sma->mid),
                ntohl (sma->qid));
    // TODO I guess this can happen, if the Ack from the peer comes before the Ack from the queue.
    // Update: Maybe QueueEntry was accidentally freed during freeing PendingMessage.
    /* this should never happen */
    // GNUNET_break (0);
    // GNUNET_SERVICE_client_drop (tc->client);
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  free_queue_entry (qe, tc);
  GNUNET_SERVICE_client_continue (tc->client);
}

References CT_COMMUNICATOR, free_queue(), free_queue_entry(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), GST_stats, GNUNET_TRANSPORT_SendMessageToAck::mid, qe, GNUNET_TRANSPORT_SendMessageToAck::qid, queue(), GNUNET_TRANSPORT_SendMessageToAck::receiver, GNUNET_TRANSPORT_SendMessageToAck::status, and tc.

Here is the call graph for this function:

handle_burst_finished()

static void handle_burst_finished ( void *  cls, const struct GNUNET_TRANSPORT_BurstFinished *  bf  )

static

The burst finished.

Parameters

cls	the client

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

{
  struct TransportClient *tc = cls;
 
  (void) bf;
  burst_running = GNUNET_NO;
  GNUNET_SERVICE_client_continue (tc->client);
}

References burst_running, GNUNET_NO, GNUNET_SERVICE_client_continue(), and tc.

Here is the call graph for this function:

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

cls	the new struct TransportClient
pid	a connected peer
value	the struct Neighbour with more information

Returns

GNUNET_OK (continue to iterate)

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

{
  struct TransportClient *tc = cls;
  struct Neighbour *neighbour = value;
 
  GNUNET_assert (CT_MONITOR == tc->type);
  for (struct Queue *q = neighbour->queue_head; NULL != q;
       q = q->next_neighbour)
  {
    struct MonitorEvent me = { .rtt = q->pd.aged_rtt,
                               .cs = q->cs,
                               .num_msg_pending = q->num_msg_pending,
                               .num_bytes_pending = q->num_bytes_pending };
 
    notify_monitor (tc, pid, q->address, q->nt, &me);
  }
  return GNUNET_OK;
}

References CT_MONITOR, GNUNET_assert, GNUNET_OK, me, notify_monitor(), 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

cls	the client
start	the start message that was sent

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

{
  struct TransportClient *tc = cls;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  tc->type = CT_MONITOR;
  tc->details.monitor.peer = start->peer;
  tc->details.monitor.one_shot = ntohl (start->one_shot);
  GNUNET_CONTAINER_multipeermap_iterate (neighbours, &notify_client_queues, tc);
  GNUNET_SERVICE_client_mark_monitor (tc->client);
  GNUNET_SERVICE_client_continue (tc->client);
}

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:

communicator_list()

static char * communicator_list ( struct Neighbour *  n, unsigned int *  num_queues  )

static

Build the 0-terminated, comma-separated list of address prefixes of the communicators that own the queues of n, without repeats.

Parameters

	n	neighbour to inspect, may be NULL
[out]	num_queues	set to the number of queues considered

Returns

list to be released with GNUNET_free()

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

{
  char *ret = GNUNET_strdup ("");
 
  *num_queues = 0;
  if (NULL == n)
    return ret;
  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
  {
    const char *prefix = q->tc->details.communicator.address_prefix;
    size_t plen = strlen (prefix);
    const char *pos;
    char *tmp;
 
    (*num_queues)++;
    if (0 == plen)
      continue;
    /* Several queues to one neighbour routinely share a communicator;
       name each one once. */
    for (pos = strstr (ret, prefix);
         NULL != pos;
         pos = strstr (pos + 1, prefix))
      if (((pos == ret) || (',' == pos[-1])) &&
          (('\0' == pos[plen]) || (',' == pos[plen])))
        break;
    if (NULL != pos)
      continue;
    GNUNET_asprintf (&tmp, "%s%s%s", ret, ('\0' == ret[0]) ? "" : ",", prefix);
    GNUNET_free (ret);
    ret = tmp;
  }
  return ret;
}

References GNUNET_asprintf(), GNUNET_free, GNUNET_strdup, prefix, q, Neighbour::queue_head, and ret.

Referenced by report_link().

Here is the call graph for this function:

Here is the caller graph for this function:

report_link()

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

static

Send the state of the virtual link value to the requesting client.

Parameters

cls	a struct LinkListContext *
pid	peer at the other end of the link
value	the struct VirtualLink * to report on

Returns

GNUNET_OK (continue to iterate)

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

{
  struct LinkListContext *llc = cls;
  struct VirtualLink *vl = value;
  struct GNUNET_TRANSPORT_LinkListResponse *resp;
  struct GNUNET_MQ_Envelope *env;
  unsigned int pending = 0;
  unsigned int num_queues = 0;
  unsigned int distance = 0;
  struct Neighbour *hop;
  char *ccs;
  size_t clen;
 
  if ((GNUNET_YES != llc->include_unconfirmed) &&
      (GNUNET_YES != vl->confirmed))
    return GNUNET_OK;
  for (struct PendingMessage *pm = vl->pending_msg_head;
       NULL != pm;
       pm = pm->next_vl)
    pending++;
  if (NULL != vl->n)
  {
    hop = vl->n;
  }
  else
  {
    /* Report the best (shortest) of the paths we currently know, and the
       communicators that carry its first hop. */
    struct DistanceVectorHop *best = NULL;
 
    distance = UINT_MAX;
    if (NULL != vl->dv)
      for (struct DistanceVectorHop *pos = vl->dv->dv_head;
           NULL != pos;
           pos = pos->next_dv)
        if (pos->distance < distance)
        {
          distance = pos->distance;
          best = pos;
        }
    if (NULL == best)
      distance = 0;   /* no paths left; report the link as adjacent */
    hop = (NULL != best) ? best->next_hop : NULL;
  }
  ccs = communicator_list (hop, &num_queues);
  clen = strlen (ccs) + 1;
  env = GNUNET_MQ_msg_extra (resp,
                             clen,
                             GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE);
  memcpy (&resp[1], ccs, clen);
  GNUNET_free (ccs);
  resp->target = *pid;
  resp->confirmed = htonl ((uint32_t) vl->confirmed);
  resp->route = htonl ((uint32_t) ((NULL != vl->n)
                                   ? GNUNET_TRANSPORT_LINK_ROUTE_DIRECT
                                   : GNUNET_TRANSPORT_LINK_ROUTE_DV));
  resp->distance = htonl ((uint32_t) distance);
  resp->num_queues = htonl ((uint32_t) num_queues);
  resp->core_recv_window = htonl ((int32_t) vl->core_recv_window);
  resp->stalled = htonl ((uint32_t) vl->cmc_count);
  resp->pending = htonl (pending);
  resp->fc_retransmit_count = htonl ((uint32_t) vl->fc_retransmit_count);
  resp->available_fc_window_size
    = GNUNET_htonll (vl->available_fc_window_size);
  resp->incoming_fc_window_size_ram
    = GNUNET_htonll (vl->incoming_fc_window_size_ram);
  resp->incoming_fc_window_size
    = GNUNET_htonll (vl->incoming_fc_window_size);
  resp->incoming_fc_window_size_used
    = GNUNET_htonll (vl->incoming_fc_window_size_used);
  resp->incoming_fc_window_size_loss
    = GNUNET_htonll ((uint64_t) vl->incoming_fc_window_size_loss);
  resp->outbound_fc_window_size
    = GNUNET_htonll (vl->outbound_fc_window_size);
  resp->outbound_fc_window_size_used
    = GNUNET_htonll (vl->outbound_fc_window_size_used);
  resp->last_fc_rtt = GNUNET_TIME_relative_hton (vl->last_fc_rtt);
  resp->other_rtt = GNUNET_TIME_relative_hton (vl->other_rtt);
  resp->last_fc_transmission
    = GNUNET_TIME_absolute_hton (vl->last_fc_transmission);
  GNUNET_MQ_send (llc->tc->mq, env);
  return GNUNET_OK;
}

References VirtualLink::available_fc_window_size, GNUNET_TRANSPORT_LinkListResponse::available_fc_window_size, VirtualLink::cmc_count, communicator_list(), VirtualLink::confirmed, GNUNET_TRANSPORT_LinkListResponse::confirmed, VirtualLink::core_recv_window, GNUNET_TRANSPORT_LinkListResponse::core_recv_window, DistanceVectorHop::distance, GNUNET_TRANSPORT_LinkListResponse::distance, VirtualLink::dv, DistanceVector::dv_head, env, VirtualLink::fc_retransmit_count, GNUNET_TRANSPORT_LinkListResponse::fc_retransmit_count, GNUNET_free, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_hton(), GNUNET_TRANSPORT_LINK_ROUTE_DIRECT, GNUNET_TRANSPORT_LINK_ROUTE_DV, GNUNET_YES, VirtualLink::incoming_fc_window_size, GNUNET_TRANSPORT_LinkListResponse::incoming_fc_window_size, VirtualLink::incoming_fc_window_size_loss, GNUNET_TRANSPORT_LinkListResponse::incoming_fc_window_size_loss, VirtualLink::incoming_fc_window_size_ram, GNUNET_TRANSPORT_LinkListResponse::incoming_fc_window_size_ram, VirtualLink::incoming_fc_window_size_used, GNUNET_TRANSPORT_LinkListResponse::incoming_fc_window_size_used, VirtualLink::last_fc_rtt, GNUNET_TRANSPORT_LinkListResponse::last_fc_rtt, VirtualLink::last_fc_transmission, GNUNET_TRANSPORT_LinkListResponse::last_fc_transmission, llc, GNUNET_TRANSPORT_LinkListContext::mq, VirtualLink::n, DistanceVectorHop::next_hop, GNUNET_TRANSPORT_LinkListResponse::num_queues, VirtualLink::other_rtt, GNUNET_TRANSPORT_LinkListResponse::other_rtt, VirtualLink::outbound_fc_window_size, GNUNET_TRANSPORT_LinkListResponse::outbound_fc_window_size, VirtualLink::outbound_fc_window_size_used, GNUNET_TRANSPORT_LinkListResponse::outbound_fc_window_size_used, pending, GNUNET_TRANSPORT_LinkListResponse::pending, VirtualLink::pending_msg_head, GNUNET_TRANSPORT_LinkListResponse::route, GNUNET_TRANSPORT_LinkListResponse::stalled, GNUNET_TRANSPORT_LinkListResponse::target, value, and Neighbour::vl.

Referenced by handle_link_list_request().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_link_list_request()

static void handle_link_list_request ( void *  cls, const struct GNUNET_TRANSPORT_LinkListRequest *  lr  )

static

A client asks for the virtual links we currently have.

Answer with one GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE per link, then a GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE_END.

Parameters

cls	the client
lr	the request

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

{
  struct TransportClient *tc = cls;
  struct LinkListContext llc = {
    .tc = tc,
    .include_unconfirmed = (int) ntohl (lr->include_unconfirmed)
  };
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *end;
 
  if (CT_NONE != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  if (GNUNET_YES == GNUNET_is_zero (&lr->peer))
  {
    GNUNET_CONTAINER_multipeermap_iterate (links, &report_link, &llc);
  }
  else
  {
    struct VirtualLink *vl = lookup_virtual_link (&lr->peer);
 
    if (NULL != vl)
      report_link (&llc, &lr->peer, vl);
  }
  env = GNUNET_MQ_msg (end,
                       GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE_END);
  GNUNET_MQ_send (tc->mq, env);
  GNUNET_SERVICE_client_continue (tc->client);
}

References CT_NONE, end, env, GNUNET_break, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_is_zero, GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_RESPONSE_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, links, llc, lookup_virtual_link(), lr, report_link(), 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

prefix

communicator name

Returns

NULL if no such transport client is available

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

{
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_COMMUNICATOR != tc->type)
      continue;
    if (NULL == tc->details.communicator.address_prefix)
      continue;   /* receive-only communicator */
    if (0 == strcmp (prefix, tc->details.communicator.address_prefix))
      return tc;
  }
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Someone suggested use of communicator for `%s', but we do not have such a communicator!\n",
    prefix);
  return NULL;
}

References clients_head, CT_COMMUNICATOR, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, prefix, and tc.

Referenced by suggest_to_connect().

Here is the caller graph for this function:

validation_challenge_freq()

static struct GNUNET_TIME_Relative validation_challenge_freq ( const struct GNUNET_PeerIdentity *  pid )

static

How slow are we allowed to get with challenges for pid?

An address of a peer nobody is waiting for may back off all the way to MAX_VALIDATION_CHALLENGE_FREQ. A peer an application client asked for and that we have no confirmed link to may not: at a day between challenges the client would be told about the peer some time next week.

Parameters

pid	peer whose address we are about to challenge

Returns

the cap for GNUNET_TIME_randomized_backoff()

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

{
  const struct VirtualLink *vl = lookup_virtual_link (pid);
 
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
    return MAX_VALIDATION_CHALLENGE_FREQ;   /* we have what we want */
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    if (CT_APPLICATION != tc->type)
      continue;
    if (NULL != GNUNET_CONTAINER_multipeermap_get (
          tc->details.application.requests,
          pid))
      return WANTED_VALIDATION_CHALLENGE_FREQ;
  }
  return MAX_VALIDATION_CHALLENGE_FREQ;
}

References clients_head, VirtualLink::confirmed, CT_APPLICATION, GNUNET_CONTAINER_multipeermap_get(), GNUNET_YES, lookup_virtual_link(), MAX_VALIDATION_CHALLENGE_FREQ, tc, and WANTED_VALIDATION_CHALLENGE_FREQ.

Referenced by validation_start_cb().

Here is the call graph for this function:

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

cls	a struct QueueQualityContext * with counters
pid	peer this is about
value	a struct Neighbour

Returns

GNUNET_OK (continue to iterate)

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

{
  struct QueueQualityContext *ctx = cls;
  struct Neighbour *n = value;
  int do_inc;
 
  (void) pid;
  do_inc = GNUNET_NO;
  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
  {
    ctx->num_queues++;
    if (0 == ctx->k--)
      ctx->q = q;
    /* FIXME-CONQ-STATISTICS: in the future, add reliability / goodput
       statistics and consider those as well here? */
    if (q->pd.aged_rtt.rel_value_us < DV_QUALITY_RTT_THRESHOLD.rel_value_us)
      do_inc = GNUNET_YES;
  }
  if (GNUNET_YES == do_inc)
    ctx->quality_count++;
  return GNUNET_OK;
}

References ctx, DV_QUALITY_RTT_THRESHOLD, GNUNET_NO, GNUNET_OK, GNUNET_YES, Neighbour::pid, q, Neighbour::queue_head, and value.

Referenced by start_dv_learn(), and transmit_dv_init().

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

cls

NULL

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

{
  struct LearnLaunchEntry *lle;
  struct QueueQualityContext qqc;
  struct TransportDVLearnMessage dvl;
  const struct GNUNET_PeerIdentity *my_identity;
 
  (void) cls;
  dvlearn_task = NULL;
  if ((GNUNET_YES == in_shutdown) || (NULL == pils))
    return;
  if (0 == GNUNET_CONTAINER_multipeermap_size (neighbours))
    return; /* lost all connectivity, cannot do learning */
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    /* PILS has not handed us an identity yet.  The first queue arriving
       schedules us with add_now(), which routinely wins that race; retry
       instead of taking the service down. */
    dvlearn_pils_backoff = GNUNET_TIME_STD_BACKOFF (dvlearn_pils_backoff);
    dvlearn_task = GNUNET_SCHEDULER_add_delayed (dvlearn_pils_backoff,
                                                 &start_dv_learn,
                                                 NULL);
    return;
  }
  dvlearn_pils_backoff = GNUNET_TIME_UNIT_ZERO;
  qqc.quality_count = 0;
  qqc.num_queues = 0;
  qqc.k = GNUNET_CONTAINER_multipeermap_size (neighbours);
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &check_connection_quality,
                                         &qqc);
  if (qqc.quality_count > DV_LEARN_QUALITY_THRESHOLD)
  {
    struct GNUNET_TIME_Relative delay;
    unsigned int factor;
 
    /* scale our retries by how far we are above the threshold */
    factor = qqc.quality_count / DV_LEARN_QUALITY_THRESHOLD;
    delay = GNUNET_TIME_relative_multiply (DV_LEARN_BASE_FREQUENCY, factor);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "At connection quality %u, will launch DV learn in %s\n",
                qqc.quality_count,
                GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
    dvlearn_task = GNUNET_SCHEDULER_add_delayed (delay, &start_dv_learn, NULL);
    return;
  }
  /* remove old entries in #dvlearn_map if it has grown too big */
  while (MAX_DV_LEARN_PENDING <=
         GNUNET_CONTAINER_multishortmap_size (dvlearn_map))
  {
    lle = lle_tail;
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multishortmap_remove (dvlearn_map,
                                                          &lle->challenge.value,
                                                          lle));
    GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
    GNUNET_free (lle);
  }
  /* setup data structure for learning */
  lle = GNUNET_new (struct LearnLaunchEntry);
  GNUNET_CRYPTO_random_block (&lle->challenge,
                              sizeof(lle->challenge));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting launch DV learn with challenge %s\n",
              GNUNET_sh2s (&lle->challenge.value));
  GNUNET_CONTAINER_DLL_insert (lle_head, lle_tail, lle);
  GNUNET_break (GNUNET_YES ==
                GNUNET_CONTAINER_multishortmap_put (
                  dvlearn_map,
                  &lle->challenge.value,
                  lle,
                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  dvl.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
  dvl.header.size = htons (sizeof(dvl));
  dvl.num_hops = htons (0);
  dvl.bidirectional = htons (0);
  dvl.non_network_delay = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO);
  dvl.monotonic_time =
    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (GST_cfg));
  // We will set the below again later
  memset (&dvl.init_sig, 0, sizeof dvl.init_sig);
  dvl.challenge = lle->challenge;
  dvl.initiator = *my_identity;
  {
    struct DvInitPS dvip = {
      .purpose.purpose = htonl (
        GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
      .purpose.size = htonl (sizeof(dvip)),
      .monotonic_time = dvl.monotonic_time,
      .challenge = lle->challenge
    };
 
    if (GNUNET_OK != sign_by_my_identity (&dvip.purpose, &dvl.init_sig))
      return;
  }
  transmit_dv_init (dvl, lle, qqc);
}

References TransportDVLearnMessage::bidirectional, TransportDVLearnMessage::challenge, LearnLaunchEntry::challenge, check_connection_quality(), DV_LEARN_BASE_FREQUENCY, DV_LEARN_QUALITY_THRESHOLD, dvlearn_map, dvlearn_pils_backoff, 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_random_block(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN, GNUNET_new, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_delayed(), GNUNET_sh2s(), GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR, GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GST_cfg, TransportDVLearnMessage::header, in_shutdown, TransportDVLearnMessage::init_sig, TransportDVLearnMessage::initiator, QueueQualityContext::k, lle_head, lle_tail, MAX_DV_LEARN_PENDING, TransportDVLearnMessage::monotonic_time, my_identity, neighbours, TransportDVLearnMessage::non_network_delay, TransportDVLearnMessage::num_hops, QueueQualityContext::num_queues, pils, GNUNET_CRYPTO_SignaturePurpose::purpose, DvInitPS::purpose, QueueQualityContext::quality_count, sign_by_my_identity(), GNUNET_MessageHeader::size, start_dv_learn(), transmit_dv_init(), GNUNET_MessageHeader::type, and GNUNET_CRYPTO_ChallengeNonceP::value.

Referenced by handle_add_queue_message(), start_dv_learn(), and transmit_dv_init().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_dv_init()

static void transmit_dv_init ( struct TransportDVLearnMessage  dvl, struct LearnLaunchEntry *  lle, struct QueueQualityContext  qqc  )

static

Finish and transmit the DV learn message dvl we initiated.

Parameters

dvl	the message, signature already filled in
lle	our launch entry for this challenge
qqc	queue quality context to pick the transmitting queue from

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

{
  if (0 == qqc.num_queues)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV learn aborted: no queue left",
                              1,
                              GNUNET_NO);
    return;
  }
  qqc.quality_count = 0;
  qqc.k = GNUNET_CRYPTO_random_u32 (qqc.num_queues);
  qqc.num_queues = 0;
  qqc.q = NULL;
  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                         &check_connection_quality,
                                         &qqc);
  if (NULL == qqc.q)
  {
    GNUNET_STATISTICS_update (GST_stats,
                              "# DV learn aborted: no queue left",
                              1,
                              GNUNET_NO);
    return;
  }
 
  /* Do this as close to transmission time as possible! */
  lle->launch_time = GNUNET_TIME_absolute_get ();
 
  queue_send_msg (qqc.q, NULL, &dvl, sizeof(dvl));
  /* reschedule this job, randomizing the time it runs (but no
     actual backoff!) */
  if (NULL != dvlearn_task)
    GNUNET_SCHEDULER_cancel (dvlearn_task);
  dvlearn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_randomize (
                                                 DV_LEARN_BASE_FREQUENCY),
                                               &start_dv_learn,
                                               NULL);
}

References check_connection_quality(), DV_LEARN_BASE_FREQUENCY, dvlearn_task, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_CRYPTO_random_u32(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_randomize(), GST_stats, QueueQualityContext::k, LearnLaunchEntry::launch_time, neighbours, QueueQualityContext::num_queues, QueueQualityContext::q, QueueQualityContext::quality_count, queue_send_msg(), and start_dv_learn().

Referenced by 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

cls	a struct Queue
pid	peer concerned (unused)
value	a struct ValidationState

Returns

GNUNET_NO if a match was found and we can stop looking

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

{
  struct Queue *q = cls;
  struct ValidationState *vs = value;
  char *address_without_port_vs;
  char *address_without_port_q;
  char *prefix_vs;
  char *prefix_q;
  int success = GNUNET_YES;
 
  // TODO Check if this is really necessary.
  address_without_port_vs = get_address_without_port (vs->address);
  address_without_port_q = get_address_without_port (q->address);
  prefix_vs = GNUNET_HELLO_address_to_prefix (vs->address);
  prefix_q = GNUNET_HELLO_address_to_prefix (q->address);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Check validation request pending for `%s' at `%s'/`%s' (vs)/(q)\n",
              GNUNET_i2s (pid),
              (NULL == address_without_port_vs) ? "<unparsable>"
              : address_without_port_vs,
              (NULL == address_without_port_q) ? "<unparsable>"
              : address_without_port_q);
  (void) pid;
  /* Only the port may differ: the address we asked to connect to is
     `PROTO-IP:0' for a NATed peer, while the queue that then materializes
     sits at `PROTO-IP:port'.  The communicator must match all the same --
     a challenge for a `tcp-' address is not answered by a `udp-' queue. */
  if ((GNUNET_YES == vs->awaiting_queue) &&
      (NULL != address_without_port_vs) &&
      (NULL != address_without_port_q) &&
      (NULL != prefix_vs) &&
      (NULL != prefix_q) &&
      (0 == strcmp (prefix_vs, prefix_q)) &&
      (0 == strcmp (address_without_port_vs, address_without_port_q)))
  {
 
    vs->awaiting_queue = GNUNET_NO;
    validation_transmit_on_queue (q, vs);
    success = GNUNET_NO;
  }
 
  GNUNET_free (address_without_port_vs);
  GNUNET_free (address_without_port_q);
  GNUNET_free (prefix_vs);
  GNUNET_free (prefix_q);
  return success;
}

References get_address_without_port(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_to_prefix(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, ValidationState::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

cls	a struct Neighbour
record	the information found, NULL for the last call
emsg	error message

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

{
  struct Neighbour *n = cls;
  struct GNUNET_TIME_AbsoluteNBO *mtbe;
 
  (void) emsg;
  if (NULL == record)
  {
    /* we're done with #neighbour_dv_monotime_cb() invocations,
       continue normal processing */
    n->get = NULL;
    n->dv_monotime_available = GNUNET_YES;
    return;
  }
  if (0 == record->value_size)
  {
    GNUNET_PEERSTORE_iteration_next (n->get, 1);
    GNUNET_break (0);
    return;
  }
  mtbe = record->value;
  n->last_dv_learn_monotime =
    GNUNET_TIME_absolute_max (n->last_dv_learn_monotime,
                              GNUNET_TIME_absolute_ntoh (*mtbe));
  GNUNET_PEERSTORE_iteration_next (n->get, 1);
}

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

{
  struct Queue *queue = cls;
  struct sockaddr_in v4;
  const char *slash;
  char *address_uri;
  char *prefix;
  char *uri_without_port;
  char *address_uri_without_port;
 
  slash = strrchr (uri, '/');
  if ((NULL == slash) || (slash - uri < 2))
  {
    GNUNET_break_op (0);   /* @a uri comes from a remote HELLO */
    return;
  }
  prefix = GNUNET_strndup (uri, (slash - uri) - 2);
  slash++;
  GNUNET_asprintf (&address_uri,
                   "%s-%s",
                   prefix,
                   slash);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "1 not global natted_address %u %s %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address,
              slash);
 
  uri_without_port = get_address_without_port (address_uri);
  if ((NULL == uri_without_port) ||
      (1 != inet_pton (AF_INET, uri_without_port, &v4.sin_addr)))
  {
    GNUNET_free (prefix);
    GNUNET_free (address_uri);
    GNUNET_free (uri_without_port);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "2 not global natted_address %u %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address);
 
  if (GNUNET_NO == queue->is_global_natted)
  {
    GNUNET_free (prefix);
    GNUNET_free (address_uri);
    GNUNET_free (uri_without_port);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "3 not global natted_address %u %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address);
 
  if (0 == strcmp (uri_without_port, address_uri))
  {
    GNUNET_free (prefix);
    GNUNET_free (address_uri);
    GNUNET_free (uri_without_port);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "4 not global natted_address %u %s %s\n",
              queue->is_global_natted,
              uri,
              queue->address);
 
  address_uri_without_port = get_address_without_port (queue->address);
  if ((NULL != address_uri_without_port) &&
      (0 == strcmp (uri_without_port, address_uri_without_port)))
  {
    queue->is_global_natted = GNUNET_NO;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "not global natted_address %u %s %s %s %s %s %u\n",
              queue->is_global_natted,
              uri,
              queue->address,
              uri_without_port,
              address_uri_without_port,
              prefix,
              GNUNET_NO);
  GNUNET_free (prefix);
  GNUNET_free (address_uri);
  GNUNET_free (address_uri_without_port);
  GNUNET_free (uri_without_port);
}

References get_address_without_port(), GNUNET_asprintf(), GNUNET_break_op, 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 14686 of file gnunet-service-transport.c.

{
  struct TransportGlobalNattedAddressClosure *tgna_cls = cls;
  struct TransportGlobalNattedAddress *tgna = value;
  char *addr = (char *) &tgna[1];
 
  /* NOTE: @a addr is NOT 0-terminated. */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Checking tgna %p with addr %.*s and length %u compare length %lu\n",
              tgna,
              (int) ntohl (tgna->address_length),
              addr,
              ntohl (tgna->address_length),
              strlen (tgna_cls->addr));
  if (strlen (tgna_cls->addr) == ntohl (tgna->address_length)
      && 0 == strncmp (addr, tgna_cls->addr, ntohl (tgna->address_length)))
  {
    tgna_cls->tgna = tgna;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring for checking global natted\n");
}

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Done with initial PEERSTORE iteration during monitoring  for checking global natted\n");
}

References GNUNET_ERROR_TYPE_DEBUG, 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 14729 of file gnunet-service-transport.c.

{
  struct Queue *queue = cls;
  struct Neighbour *neighbour = queue->neighbour;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_MessageHeader *hello;
  struct TransportGlobalNattedAddressClosure tgna_cls;
  size_t address_len_without_port;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  /* @a hello was published by a remote peer and may be malformed. */
  hello = hello_from_record (record);
  if (NULL == hello)
  {
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  queue->is_global_natted = GNUNET_YES;
  parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
  if (NULL == parser)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "HELLO cannot be parsed!\n");
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "before not global natted %u\n",
              queue->is_global_natted);
  GNUNET_HELLO_parser_iterate (parser,
                               &iterate_address_and_compare_cb,
                               queue);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "after not global natted %u\n",
              queue->is_global_natted);
  GNUNET_HELLO_parser_free (parser);
 
  tgna_cls.addr = get_address_without_port (queue->address);
  if (NULL == tgna_cls.addr)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
    return;
  }
  address_len_without_port = strlen (tgna_cls.addr);
  /*{
    char buf[address_len_without_port + 1];
 
      GNUNET_memcpy (&buf, addr, address_len_without_port);
      buf[address_len_without_port] = '\0';
      GNUNET_free (addr);
      GNUNET_memcpy (tgna_cls.addr, buf, address_len_without_port + 1);
      }*/
  tgna_cls.tgna = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (neighbour->natted_addresses,
                                              &neighbour->pid,
                                              &contains_address,
                                              &tgna_cls);
  if (NULL != tgna_cls.tgna)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                " tgna_cls.tgna tgna %p %lu %u %u\n",
                tgna_cls.tgna,
                neighbour->size_of_global_addresses,
                ntohl (tgna_cls.tgna->address_length),
                neighbour->number_of_addresses);
  if (NULL == tgna_cls.tgna && GNUNET_YES == queue->is_global_natted)
  {
    struct TransportGlobalNattedAddress *tgna;
 
    tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress)
                          + address_len_without_port);
    tgna->address_length = htonl (address_len_without_port);
    GNUNET_memcpy (&tgna[1], tgna_cls.addr, address_len_without_port);
    GNUNET_CONTAINER_multipeermap_put (neighbour->natted_addresses,
                                       &neighbour->pid,
                                       tgna,
                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
    neighbour->number_of_addresses++;
    /* MUST match what is subtracted on removal (and what
       #add_global_addresses() actually copies), or the accounting drifts. */
    neighbour->size_of_global_addresses += address_len_without_port;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Created tgna %p with address %s and length %lu\n",
                tgna,
                tgna_cls.addr,
                address_len_without_port + 1);
  }
  else if (NULL != tgna_cls.tgna && GNUNET_NO == queue->is_global_natted)
  {
    GNUNET_CONTAINER_multipeermap_remove (neighbour->natted_addresses,
                                          &neighbour->pid,
                                          tgna_cls.tgna);
    GNUNET_assert (neighbour->size_of_global_addresses >= ntohl (tgna_cls.tgna->
                                                                 address_length)
                   );
    neighbour->size_of_global_addresses -= ntohl (tgna_cls.tgna->address_length)
    ;
    GNUNET_assert (0 < neighbour->number_of_addresses);
    neighbour->number_of_addresses--;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "removed tgna %p\n",
                tgna_cls.tgna);
    GNUNET_free (tgna_cls.tgna);
  }
  GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
  GNUNET_free (tgna_cls.addr);
}

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, hello_from_record(), iterate_address_and_compare_cb(), Neighbour::natted_addresses, Neighbour::number_of_addresses, 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

cls	the client
aqm	the send message that was sent

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

{
  struct TransportClient *tc = cls;
  struct Queue *queue;
  struct Neighbour *neighbour;
  const char *addr;
  uint16_t addr_len;
 
  if (ntohl (aqm->mtu) <= sizeof(struct TransportFragmentBoxMessage))
  {
    /* MTU so small as to be useless for transmissions,
       required for #fragment_message()! */
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  /* This may simply be a queue update.  Match on the peer as well as the
     QID: the communicator's key for a queue is the pair, and
     #handle_send_msg() on its side looks both of them up.  Matching on the
     QID alone let an ADD_QUEUE for a *different* peer be folded into an
     existing queue, leaving @e neighbour pointing at the old peer -- after
     which every SEND_MSG we put on it carries a receiver the communicator
     cannot match, and comes straight back as "queue no longer exists". */
  for (queue = tc->details.communicator.queue_head;
       NULL != queue;
       queue = queue->next_client)
  {
    if (queue->qid != ntohl (aqm->qid))
      continue;
    if (0 != GNUNET_memcmp (&queue->neighbour->pid, &aqm->receiver))
      continue;
    break;
  }
 
  if (NULL != queue)
  {
    neighbour = queue->neighbour;
  }
  else
  {
    struct GNUNET_TIME_Absolute validated_until = GNUNET_TIME_UNIT_ZERO_ABS;
 
    neighbour = lookup_neighbour (&aqm->receiver);
    if (NULL == neighbour)
    {
      neighbour = GNUNET_new (struct Neighbour);
      neighbour->natted_addresses = GNUNET_CONTAINER_multipeermap_create (16,
                                                                          GNUNET_YES);
      neighbour->pid = aqm->receiver;
      /* Give a fresh neighbour a full window to say something. */
      neighbour->last_inbound = GNUNET_TIME_absolute_get ();
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CONTAINER_multipeermap_put (
                       neighbours,
                       &neighbour->pid,
                       neighbour,
                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
      neighbour->get =
        GNUNET_PEERSTORE_iteration_start (peerstore,
                                          "transport",
                                          &neighbour->pid,
                                          GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
                                          &neighbour_dv_monotime_cb,
                                          neighbour);
    }
    addr_len = ntohs (aqm->header.size) - sizeof(*aqm);
    addr = (const char *) &aqm[1];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "New queue %s to %s available with QID %u and q_len %" PRIu64
                " and mtu %u\n",
                addr,
                GNUNET_i2s (&aqm->receiver),
                ntohl (aqm->qid),
                GNUNET_ntohll (aqm->q_len),
                ntohl (aqm->mtu));
    queue = GNUNET_malloc (sizeof(struct Queue) + addr_len);
    queue->tc = tc;
    for (struct Queue *q = neighbour->queue_head; NULL != q; q = q->
                                                                 next_neighbour)
      validated_until = GNUNET_TIME_absolute_max (validated_until, q->
                                                  validated_until);
    /* Inherit the validity of the sibling queues, but only while it is
       still in the future -- copying an already expired timestamp is
       pointless (and the condition used to be inverted). */
    if (0 != GNUNET_TIME_absolute_get_remaining (validated_until).rel_value_us)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "New queue with QID %u inherit validated until\n",
                  ntohl (aqm->qid));
      queue->validated_until = validated_until;
    }
    queue->address = (const char *) &queue[1];
    queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
    queue->qid = ntohl (aqm->qid);
    queue->neighbour = neighbour;
    if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (aqm->q_len))
      queue->unlimited_length = GNUNET_YES;
    queue->q_capacity = GNUNET_ntohll (aqm->q_len);
    memcpy (&queue[1], addr, addr_len);
    /* notify monitors about new queue */
    {
      struct MonitorEvent me = { .rtt = queue->pd.aged_rtt, .cs = queue->cs };
 
      notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
    }
    GNUNET_CONTAINER_MDLL_insert (neighbour,
                                  neighbour->queue_head,
                                  neighbour->queue_tail,
                                  queue);
    GNUNET_CONTAINER_MDLL_insert (client,
                                  tc->details.communicator.queue_head,
                                  tc->details.communicator.queue_tail,
                                  queue);
 
  }
  queue->mtu = ntohl (aqm->mtu);
  queue->nt = ntohl (aqm->nt);
  queue->cs = ntohl (aqm->cs);
  queue->idle = GNUNET_YES;
 
  if (NULL == queue->mo)
  {
    /* Only for a NEW queue: on a queue update this used to start a second
       monitor and leak the first one. */
    struct sockaddr_in v4;
    char *addr_without = get_address_without_port (queue->address);
    if ((NULL != addr_without) &&
        (1 == inet_pton (AF_INET, addr_without, &v4.sin_addr)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "start not global natted\n");
      queue->mo = GNUNET_PEERSTORE_monitor_start (GST_cfg,
                                                  GNUNET_YES,
                                                  "peerstore",
                                                  &neighbour->pid,
                                                  GNUNET_PEERSTORE_HELLO_KEY,
                                                  &
                                                  check_for_global_natted_error_cb,
                                                  NULL,
                                                  &
                                                  check_for_global_natted_sync_cb,
                                                  NULL,
                                                  &check_for_global_natted,
                                                  queue);
    }
    GNUNET_free (addr_without);
  }
  /* check if valdiations are waiting for the queue */
  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (validation_map,
                                                            &aqm->receiver))
    (void) GNUNET_CONTAINER_multipeermap_get_multiple (
      validation_map,
      &aqm->receiver,
      &check_validation_request_pending,
      queue);
  /* Always (also) validate the address of the queue itself.  A pending
     validation served above may well be for a *different* address string:
     #check_validation_request_pending() matches on the IP only, so a
     validation state waiting for the NAT address `PROTO-IP:0' is happily
     satisfied by a queue at `PROTO-IP:12345'.  If we stopped here,
     #handle_validation_response() would later look for a queue at
     `PROTO-IP:0' -- which never exists -- and drop the successful
     validation on the floor without ever creating the virtual link.  That
     is exactly what happens to the second of two peers behind the same
     NAT, as both of them advertise the very same `PROTO-IP:0'. */
  start_address_validation (&aqm->receiver, queue->address);
  /* look for traffic for this queue */
  // TODO Check whether this makes any sense at all.
  /*schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
    queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT);*/
  /* might be our first queue, try launching DV learning */
  if (NULL == dvlearn_task)
    dvlearn_task = GNUNET_SCHEDULER_add_now (&start_dv_learn, NULL);
  GNUNET_SERVICE_client_continue (tc->client);
}

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_memcmp, 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_TIME_absolute_get(), 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, Neighbour::last_inbound, 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, GNUNET_TRANSPORT_AddQueueMessage::receiver, GNUNET_TIME_Relative::rel_value_us, 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

cls	the transport client.
msg	Message struct.

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

{
  struct TransportClient *tc = cls;
  struct Queue *target_queue = NULL;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    /* Without this we walk `details.communicator.queue_head' for a client
       whose union holds something else entirely. */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received queue update message for %u with q_len %llu and mtu %u\n",
              ntohl (msg->qid),
              (unsigned long long) GNUNET_ntohll (msg->q_len),
              ntohl (msg->mtu));
  for (target_queue = tc->details.communicator.queue_head;
       NULL != target_queue;
       target_queue = target_queue->next_client)
  {
    if (ntohl (msg->qid) == target_queue->qid)
      break;
  }
  if (NULL == target_queue)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Queue to update no longer exists! Discarding update.\n");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
 
  target_queue->nt = ntohl (msg->nt);
  target_queue->mtu = ntohl (msg->mtu);
  target_queue->cs = ntohl (msg->cs);
  target_queue->priority = ntohl (msg->priority);
  /* The update message indicates how many messages
   * the queue should be able to handle.
   */
  if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (msg->q_len))
    target_queue->unlimited_length = GNUNET_YES;
  else
    target_queue->unlimited_length = GNUNET_NO;
  target_queue->q_capacity += GNUNET_ntohll (msg->q_len);
  if (0 < target_queue->q_capacity)
    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
                                target_queue,
                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
  GNUNET_SERVICE_client_continue (tc->client);
}

References Queue::cs, CT_COMMUNICATOR, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), 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

cls	the struct TransportClient
cqr	confirmation message

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

{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_STATISTICS_update (GST_stats,
                            "# Suggestions succeeded at communicator",
                            1,
                            GNUNET_NO);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Request #%u for communicator to create queue succeeded\n",
              (unsigned int) ntohs (cqr->request_id));
  GNUNET_SERVICE_client_continue (tc->client);
}

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

cls	the struct TransportClient
cqr	failure message

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

{
  struct TransportClient *tc = cls;
 
  if (CT_COMMUNICATOR != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Request #%u for communicator to create queue failed\n",
              (unsigned int) ntohl (cqr->request_id));
  GNUNET_STATISTICS_update (GST_stats,
                            "# Suggestions failed in queue creation at communicator",
                            1,
                            GNUNET_NO);
  GNUNET_SERVICE_client_continue (tc->client);
}

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

An application client no longer wants us to connect to a peer it asked for earlier.

Parameters

cls	handle to the client
msg	the request to cancel

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

{
  struct TransportClient *tc = cls;
  struct PeerRequest *pr;
 
  if (CT_APPLICATION != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  pr = GNUNET_CONTAINER_multipeermap_get (tc->details.application.requests,
                                          &msg->peer);
  if (NULL == pr)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  (void) stop_peer_request (tc, &pr->pid, pr);
  GNUNET_SERVICE_client_continue (tc->client);
}

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

{
  struct Queue *q;
  int pfx_len;
  const char *eou;
  char *address;
  (void) cls;
 
  eou = strstr (uri,
                "://");
  if ((NULL == eou) || (eou == uri))
  {
    /* @a uri comes from a HELLO some remote peer published. */
    GNUNET_break_op (0);
    return;
  }
  pfx_len = eou - uri;
  eou += 3;
  GNUNET_asprintf (&address,
                   "%.*s-%s",
                   pfx_len,
                   uri,
                   eou);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "hello for client %s\n",
              address);
 
  q = find_queue (pid, address);
  if (NULL == q)
  {
    suggest_to_connect (pid, address);
  }
  else
    start_address_validation (pid, address);
  GNUNET_free (address);
}

References address, find_queue(), GNUNET_asprintf(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, 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

cls	closure, a struct PeerRequest
record	peerstore record information
emsg	error message, or NULL if no errors

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

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct PeerRequest *pr = cls;
  struct GNUNET_HELLO_Parser *parser;
  const struct GNUNET_MessageHeader *hello;
 
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Got failure from PEERSTORE: %s\n",
                emsg);
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  if (NULL == record)
  {
    GNUNET_break (0);
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "No identity given yet!\n");
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  hello = hello_from_record (record);
  if (NULL == hello)
  {
    /* MUST still ask for the next record: a bad one is not a reason to
       stall this monitor forever. */
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  if (0 == GNUNET_memcmp (&record->peer, my_identity))
  {
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  parser = GNUNET_HELLO_parser_from_msg (hello, &record->peer);
  if (NULL == parser)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "HELLO cannot be parsed!\n");
    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "HELLO for `%s' could be parsed, iterating addresses...!\n",
              GNUNET_i2s (GNUNET_HELLO_parser_get_id (parser)));
  GNUNET_HELLO_parser_iterate (parser,
                               hello_for_client_cb,
                               NULL);
  GNUNET_HELLO_parser_free (parser);
  /* MUST ask for the next record, or this monitor stalls after one HELLO */
  GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
}

References GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_get_id(), GNUNET_HELLO_parser_iterate(), GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_PEERSTORE_monitor_next(), GNUNET_PILS_get_identity(), hello_for_client_cb(), hello_from_record(), my_identity, PeerRequest::nc, pils, PeerRequest::pr, and record().

Referenced by start_peer_request_monitor().

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by start_peer_request_monitor().

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Done with initial PEERSTORE iteration during monitoring\n");
}

References GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by start_peer_request_monitor().

Here is the caller graph for this function:

start_peer_request_monitor()

static void start_peer_request_monitor ( struct PeerRequest *  pr )

static

(Re)start the PEERSTORE HELLO monitor of pr.

Starting the monitor with iterate_first also replays what PEERSTORE already knows about pid, which is what makes this useful as a retry: after the initial replay the monitor only reports changes, and a peer whose HELLO does not change is one we would otherwise never look at again.

Parameters

pr	request to (re)start the monitor for

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

{
  if (NULL != pr->nc)
    GNUNET_PEERSTORE_monitor_stop (pr->nc);
  /* Monitor only @e pid.  With NULL every application request sees every
     HELLO in PEERSTORE, so a client asking for one peer made us suggest a
     connection to -- and start an address validation for -- every peer we
     have ever heard of, once per request.  #try_to_bring_link_up() had the
     same bug and was already fixed the same way. */
  pr->nc =
    GNUNET_PEERSTORE_monitor_start (GST_cfg,
                                    GNUNET_YES,
                                    "peerstore",
                                    &pr->pid,
                                    GNUNET_PEERSTORE_HELLO_KEY,
                                    &hello_for_client_error_cb,
                                    NULL,
                                    &hello_for_client_sync_cb,
                                    NULL,
                                    &handle_hello_for_client,
                                    pr);
}

References GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_PEERSTORE_monitor_stop(), GNUNET_YES, GST_cfg, handle_hello_for_client(), hello_for_client_error_cb(), hello_for_client_sync_cb(), PeerRequest::nc, and PeerRequest::pid.

Referenced by handle_suggest(), and suggest_retry_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

suggest_retry_cb()

static void suggest_retry_cb ( void *  cls )

static

Task run for as long as an application client wants a link to pid that we do not have.

Nothing else retries: the validation heap backs off to MAX_VALIDATION_CHALLENGE_FREQ (a day) and drops the validation state entirely once it expires, and the HELLO monitor only fires when the HELLO actually changes – which, for a peer we cannot reach, it does not.

Parameters

cls	the struct PeerRequest

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

{
  struct PeerRequest *pr = cls;
  struct VirtualLink *vl;
 
  pr->retry_task = NULL;
  vl = lookup_virtual_link (&pr->pid);
  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
  {
    /* The client has what it asked for.  Keep watching cheaply, and start
       over from the short interval when the link goes away again. */
    pr->retry_backoff = SUGGEST_RETRY_MIN;
    pr->retry_task = GNUNET_SCHEDULER_add_delayed (SUGGEST_RETRY_MAX,
                                                   &suggest_retry_cb,
                                                   pr);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Retrying to connect to %s, an application client wants it\n",
              GNUNET_i2s (&pr->pid));
  GNUNET_STATISTICS_update (GST_stats,
                            "# link setup retries for application clients",
                            1,
                            GNUNET_NO);
  /* Addresses we already track, queues we still have, and a fresh look in
     PEERSTORE. */
  try_to_bring_link_up (&pr->pid);
  /* ... plus a replay of what PEERSTORE has for this peer, which is the
     only way back once the validation state expired and the queues are
     gone. */
  start_peer_request_monitor (pr);
  pr->retry_backoff = GNUNET_TIME_randomized_backoff (pr->retry_backoff,
                                                      SUGGEST_RETRY_MAX);
  pr->retry_task = GNUNET_SCHEDULER_add_delayed (pr->retry_backoff,
                                                 &suggest_retry_cb,
                                                 pr);
}

References VirtualLink::confirmed, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_randomized_backoff(), GNUNET_YES, GST_stats, lookup_virtual_link(), PeerRequest::pid, PeerRequest::pr, PeerRequest::retry_backoff, PeerRequest::retry_task, start_peer_request_monitor(), suggest_retry_cb(), SUGGEST_RETRY_MAX, SUGGEST_RETRY_MIN, and try_to_bring_link_up().

Referenced by handle_suggest(), and suggest_retry_cb().

Here is the call graph for this function:

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

cls	handle to the client
msg	the start message

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

{
  struct TransportClient *tc = cls;
  const struct GNUNET_PeerIdentity *my_identity;
  struct PeerRequest *pr;
 
  if (CT_NONE == tc->type)
  {
    tc->type = CT_APPLICATION;
    tc->details.application.requests =
      GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
  }
  if (CT_APPLICATION != tc->type)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Still waiting for own identity!\n");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client suggested we talk to %s with preference %d at rate %u\n",
              GNUNET_i2s (&msg->peer),
              (int) ntohl (msg->pk),
              (int) ntohl (msg->bw.value__));
  if (0 == GNUNET_memcmp (my_identity, &msg->peer))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Client suggested connection to ourselves, ignoring...\n");
    GNUNET_SERVICE_client_continue (tc->client);
    return;
  }
  pr = GNUNET_new (struct PeerRequest);
  pr->tc = tc;
  pr->pid = msg->peer;
  pr->bw = msg->bw;
  pr->pk = ntohl (msg->pk);
  if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_put (
        tc->details.application.requests,
        &pr->pid,
        pr,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_break (0);
    GNUNET_free (pr);
    GNUNET_SERVICE_client_drop (tc->client);
    return;
  }
  start_peer_request_monitor (pr);
  /* The monitor alone only ever fires again if the HELLO *changes*.  Keep
     asking for the link ourselves for as long as the client wants it. */
  pr->retry_backoff = SUGGEST_RETRY_MIN;
  pr->retry_task = GNUNET_SCHEDULER_add_delayed (pr->retry_backoff,
                                                 &suggest_retry_cb,
                                                 pr);
  GNUNET_SERVICE_client_continue (tc->client);
}

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_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_new, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, msg, my_identity, pils, PeerRequest::pr, start_peer_request_monitor(), suggest_retry_cb(), SUGGEST_RETRY_MIN, 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

cls	a struct TransportClient *
m	message to verify

Returns

GNUNET_OK on success

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

{
  (void) cls;
  GNUNET_MQ_check_zero_termination (m);
  return GNUNET_OK;
}

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

cls	a struct TransportClient *
m	message to verify

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

{
  struct TransportClient *tc = cls;
  struct Queue *q;
 
  q = find_queue (&m->peer, (const char *) &m[1]);
  if (NULL == q)
  {
    suggest_to_connect (&m->peer, (const char *) &m[1]);
  }
  else
    start_address_validation (&m->peer, (const char *) &m[1]);
  GNUNET_SERVICE_client_continue (tc->client);
}

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

cls	NULL
pid	unused
value	a struct Neighbour

Returns

GNUNET_OK (always)

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

{
  struct Neighbour *neighbour = value;
 
  (void) cls;
  (void) pid;
  GNUNET_break (0);  // should this ever happen?
  free_neighbour (neighbour, GNUNET_YES);
 
  return GNUNET_OK;
}

References free_neighbour(), GNUNET_break, GNUNET_OK, GNUNET_YES, Neighbour::pid, and value.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

free_virtual_link_cb()

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

static

Free virtual link entry.

A link with neither a ‘struct Neighbour’ nor a ‘struct DistanceVector’ – one we created from an inbound FLOW_CONTROL message and that never got confirmed – is owned by nothing but its unconfirmed_timeout_task, so unlike neighbours it routinely survives to here. Not a bug, no GNUNET_break().

Parameters

cls	NULL
pid	unused
value	a ‘struct VirtualLink’

Returns

GNUNET_OK (always)

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

{
  struct VirtualLink *vl = value;
 
  (void) cls;
  (void) pid;
  free_virtual_link (vl);
 
  return GNUNET_OK;
}

References free_virtual_link(), GNUNET_OK, 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

cls	NULL
pid	unused
value	a struct DistanceVector

Returns

GNUNET_OK (always)

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

{
  struct DistanceVector *dv = value;
 
  (void) cls;
  (void) pid;
  free_dv_route (dv);
 
  return GNUNET_OK;
}

References free_dv_route(), GNUNET_OK, 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

cls	NULL
pid	unused
value	a struct ValidationState

Returns

GNUNET_OK (always)

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

{
  struct ValidationState *vs = value;
 
  (void) cls;
  (void) pid;
  free_validation_state (vs);
  return GNUNET_OK;
}

References free_validation_state(), GNUNET_OK, ValidationState::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

cls	NULL
key	unused
value	a struct PendingAcknowledgement

Returns

GNUNET_OK (always)

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

{
  struct PendingAcknowledgement *pa = value;
 
  (void) cls;
  (void) key;
  free_pending_acknowledgement (pa);
  return GNUNET_OK;
}

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

cls	NULL
pid	unused
value	a struct AcknowledgementCummulator

Returns

GNUNET_OK (always)

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

{
  struct AcknowledgementCummulator *ac = value;
 
  (void) cls;
  (void) pid;
  /* @e task is armed for the whole life of @a ac -- but
     #transmit_cummulative_ack_cb() clears it before re-arming, and it
     routes a message while it is clear.  #GNUNET_SCHEDULER_cancel()
     dereferences its argument unconditionally. */
  if (NULL != ac->task)
  {
    GNUNET_SCHEDULER_cancel (ac->task);
    ac->task = NULL;
  }
  GNUNET_free (ac);
  return GNUNET_OK;
}

References GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), AcknowledgementCummulator::task, and value.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

get_client_type_name()

static const char * get_client_type_name ( enum ClientType  type )

static

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

{
  switch (type)
  {
  case CT_CORE:
    return "CORE";
  case CT_MONITOR:
    return "MONITOR";
  case CT_COMMUNICATOR:
    return "COMMUNICATOR";
  case CT_APPLICATION:
    return "APPLICATION";
  default:
    return "UNKNOWN";
  }
}

References CT_APPLICATION, CT_COMMUNICATOR, CT_CORE, CT_MONITOR, and type.

Referenced by drop_remaining_clients(), and shutdown_task().

Here is the caller graph for this function:

drop_remaining_clients()

static void drop_remaining_clients ( void *  cls )

static

The grace period we gave our clients to disconnect on their own expired.

Drop whoever is left, which gets us to do_shutdown() via client_disconnect_cb().

Parameters

cls	closure, unused

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

{
  client_grace_task = NULL;
  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Client did not disconnect within the shutdown grace period, "
                "dropping it: %s\n",
                get_client_type_name (tc->type));
  }
  /* We use #GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, so the service will NOT
     drop clients for us.  Without this we would wait forever for them to
     leave on their own and never reach #do_shutdown(). */
  GNUNET_SERVICE_shutdown (GST_service);
  /* Dropping the clients ran #client_disconnect_cb() for each of them, so
     #do_shutdown() has normally run by now; it is idempotent, and this
     covers the case where there was nothing left to drop. */
  do_shutdown (cls);
}

References client_grace_task, clients_head, do_shutdown, get_client_type_name(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_SERVICE_shutdown(), GST_service, and tc.

Referenced by shutdown_task().

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

{
  in_shutdown = GNUNET_YES;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Shutdown task executed\n");
  if (NULL != clients_head)
  {
    for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Waiting for client to disconnect: %s\n",
                  get_client_type_name (tc->type));
    }
    /* Give them a chance to shut down cleanly; #client_disconnect_cb() calls
       #do_shutdown() once the last one is gone, and #do_shutdown() cancels
       this task. */
    client_grace_task =
      GNUNET_SCHEDULER_add_delayed (SHUTDOWN_CLIENT_GRACE_PERIOD,
                                    &drop_remaining_clients,
                                    cls);
    return;
  }
  do_shutdown (cls);
}

References client_grace_task, clients_head, do_shutdown, drop_remaining_clients(), get_client_type_name(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, in_shutdown, SHUTDOWN_CLIENT_GRACE_PERIOD, and tc.

Here is the call graph for this function:

update_hello_from_pid_change_cb()

static void update_hello_from_pid_change_cb ( void *  cls, int  success  )

static

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

{
  struct UpdateHelloFromPidCtx *pc = cls;
 
  /* NOTE: @a success is GNUNET_OK even when #hello_add_iter() decided not to
     store anything because PEERSTORE already holds a HELLO that expires
     later; the API reports the desired state, not whether it wrote.  So this
     says "we have a current HELLO on record", not "we just wrote one". */
  if (GNUNET_OK != success)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to store our new hello with peerstore\n");
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Our hello is current in peerstore\n");
  GNUNET_free (pc);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, and pc.

Referenced by pils_pid_change_cb().

Here is the caller graph for this function:

print_address_list()

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

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%s\n", uri);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and uri.

Referenced by pils_pid_change_cb().

Here is the caller graph for this function:

pils_pid_change_cb()

static void pils_pid_change_cb ( void *  cls, const struct GNUNET_HELLO_Parser *  parser, const struct GNUNET_HashCode *  hash  )

static

Callback called when pils service updates us with our new peer identity.

Parameters

cls	closure given to GNUNET_PILS_connect
parser	the new HELLO from which the PID can be extracted
hash	The hash of addresses the peer id is based on. This hash is also returned by #GNUNET_PILS_feed_address.

FIXME we may want to have a sanity check here that verifies that our address list in the builder is the same as the one in the parser (and hence derived from the correct set). If it is NOT, then it is very likely that PILS is behind and will send another update shortly. In this case, we may want to hold off and not generate the new HELLO.

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

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_MQ_Envelope *env;
  const struct GNUNET_MessageHeader *msg;
  struct UpdateHelloFromPidCtx *sc;
  struct GNUNET_HELLO_Builder *nbuilder;
  struct GNUNET_PeerIdentity npid;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  GNUNET_assert (my_identity);
 
  if (NULL == GST_my_hello)
    GST_my_hello = GNUNET_HELLO_builder_new ();
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My current identity is `%s'\n",
              GNUNET_i2s_full (my_identity));
  nbuilder = GNUNET_HELLO_builder_from_parser (parser,
                                               &npid);
  if (GNUNET_NO ==
      GNUNET_HELLO_builder_address_list_cmp (GST_my_hello, nbuilder))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "New PID from PILS is derived from address list inconsistent with ours. Ignoring...\n");
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Proposed address list:\n");
    GNUNET_HELLO_builder_iterate (nbuilder, &print_address_list, NULL);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Current address list:\n");
    GNUNET_HELLO_builder_iterate (GST_my_hello, &print_address_list, NULL);
    GNUNET_HELLO_builder_free (nbuilder);
    return;
  }
  GNUNET_HELLO_builder_free (GST_my_hello);
  GST_my_hello = nbuilder;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My new identity is `%s'\n",
              GNUNET_i2s_full (my_identity));
  env = GNUNET_HELLO_parser_to_env (parser);
  msg = GNUNET_MQ_env_get_msg (env);
  sc = GNUNET_new (struct UpdateHelloFromPidCtx);
  sc->sc = GNUNET_PEERSTORE_hello_add (peerstore,
                                       msg,
                                       update_hello_from_pid_change_cb,
                                       sc);
  GNUNET_free (env);
}

References env, GNUNET_assert, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELLO_builder_address_list_cmp(), GNUNET_HELLO_builder_free(), GNUNET_HELLO_builder_from_parser(), GNUNET_HELLO_builder_iterate(), GNUNET_HELLO_builder_new(), GNUNET_HELLO_parser_to_env(), GNUNET_i2s_full(), GNUNET_log, GNUNET_MQ_env_get_msg(), GNUNET_new, GNUNET_NO, GNUNET_PEERSTORE_hello_add(), GNUNET_PILS_get_identity(), GST_my_hello, msg, my_identity, peerstore, pils, print_address_list(), sc, and update_hello_from_pid_change_cb().

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

cls	closure
c	configuration to use
service	the initialized service

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

{
  (void) cls;
  /* setup globals */
  GST_service = service;
  hello_mono_time = GNUNET_TIME_absolute_get_monotonic (c);
  in_shutdown = GNUNET_NO;
  GST_cfg = c;
  backtalkers = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
  pending_acks = GNUNET_CONTAINER_multiuuidmap_create (32768, GNUNET_YES);
  ack_cummulators = GNUNET_CONTAINER_multipeermap_create (256, GNUNET_YES);
  neighbours = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
  links = GNUNET_CONTAINER_multipeermap_create (512, GNUNET_YES);
  dv_routes = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
  dvlearn_map = GNUNET_CONTAINER_multishortmap_create (2 * MAX_DV_LEARN_PENDING,
                                                       GNUNET_YES);
  validation_map = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
  revalidation_map = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_YES);
  validation_heap =
    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  // TODO check for all uses of GST_my_hello that it is not used uninitialized
  use_burst = GNUNET_CONFIGURATION_get_value_yesno (GST_cfg,
                                                    "transport",
                                                    "USE_BURST_NAT");
  if (GNUNET_SYSERR == use_burst)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Could not configure burst nat use. Default to no.\n");
  GST_my_hello = GNUNET_HELLO_builder_new ();
  GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  peerstore = GNUNET_PEERSTORE_connect (GST_cfg);
  nh = GNUNET_NAT_register (GST_cfg,
                            "transport",
                            0,
                            0,
                            NULL,
                            0,
                            NULL,
                            NULL,
                            NULL);
  if (NULL == peerstore)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  pils = GNUNET_PILS_connect (GST_cfg,
                              pils_pid_change_cb,
                              NULL);          // FIXME we need to wait for
  // our first peer id before
  // we can start the service
  // completely - PILS in turn
  // waits for the first
  // addresses from the
  // communicators in order to
  // be able to generate a
  // peer id
  if (NULL == pils)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  /* Decapsulate DV box ephemeral keys ourselves.  #handle_dv_box() needs
     the key material while it still has the box, which points into the
     communicator's inbound message and is gone the moment the handler
     returns -- so the asynchronous answer arrived to a dangling @a dvb. */
  if (GNUNET_OK !=
      GNUNET_PILS_enable_private_key (pils))
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to load our private key, "
                   "cannot open DV boxes addressed to us\n"));
}

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_ERROR_TYPE_WARNING, GNUNET_HELLO_builder_new(), GNUNET_log, GNUNET_NAT_register(), GNUNET_NO, GNUNET_OK, GNUNET_PEERSTORE_connect(), GNUNET_PILS_connect(), GNUNET_PILS_enable_private_key(), 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_service, GST_stats, hello_mono_time, in_shutdown, links, MAX_DV_LEARN_PENDING, neighbours, nh, peerstore, pending_acks, pils, pils_pid_change_cb(), 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_hd_fixed_size(link_list_request, GNUNET_MESSAGE_TYPE_TRANSPORT_LINK_LIST_REQUEST, struct GNUNET_TRANSPORT_LinkListRequest, 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 3130 of file gnunet-service-transport.c.

Referenced by detach_cmcs_from_client(), 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 3135 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 3140 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 3145 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 3150 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 3155 of file gnunet-service-transport.c.

Referenced by forward_dv_box(), and send_msg_from_cache().

clients_head

struct TransportClient* clients_head

static

Head of linked list of all clients to this service.

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

Referenced by client_connect_cb(), client_disconnect_cb(), cores_send_connect_info(), cores_send_disconnect_info(), drop_remaining_clients(), finish_handling_raw_message(), handle_backchannel_encapsulation(), lookup_communicator(), notify_monitors(), shutdown_task(), start_burst(), and validation_challenge_freq().

clients_tail

struct TransportClient* clients_tail

static

Tail of linked list of all clients to this service.

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

Referenced by client_connect_cb(), and client_disconnect_cb().

GST_stats

struct GNUNET_STATISTICS_Handle* GST_stats

static

Statistics handle.

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

Referenced by backtalker_monotime_cb(), check_link_down(), core_fc_stalled(), decaps_dv_box_cont(), demultiplex_with_cmc(), do_shutdown(), finish_handling_raw_message(), free_queue(), free_queue_entry(), free_timedout_queue_entry(), get_network_latency(), handle_backchannel_encapsulation(), handle_client_recv_ok(), handle_client_send(), handle_del_queue_message(), handle_dv_box(), handle_dv_learn(), handle_flow_control(), handle_fragment_box(), handle_queue_create_fail(), handle_queue_create_ok(), handle_raw_message(), handle_reliability_ack(), handle_send_message_ack(), handle_validation_response(), learn_dv_path(), peerstore_store_validation_cb(), route_control_message_without_fc(), route_via_neighbour(), run(), schedule_transmit_on_queue(), sign_by_my_identity(), suggest_retry_cb(), suggest_to_connect(), transmit_dv_init(), and unconfirmed_link_timeout().

GST_cfg

const struct GNUNET_CONFIGURATION_Handle* GST_cfg

static

Configuration handle.

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

Referenced by consider_sending_fc(), handle_add_queue_message(), handle_validation_response(), revalidate_now_cb(), run(), sign_ephemeral(), start_address_validation(), start_dv_learn(), start_peer_request_monitor(), try_to_bring_link_up(), validation_start_cb(), and validation_transmit_on_queue().

GST_service

struct GNUNET_SERVICE_Handle* GST_service

static

Our service handle; needed to force-disconnect clients that did not go away within SHUTDOWN_CLIENT_GRACE_PERIOD, as we use GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN.

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

Referenced by drop_remaining_clients(), and run().

client_grace_task

struct GNUNET_SCHEDULER_Task* client_grace_task

static

Task run when SHUTDOWN_CLIENT_GRACE_PERIOD expired and clients are still connected, or NULL.

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

Referenced by do_shutdown(), drop_remaining_clients(), and shutdown_task().

GST_my_hello

struct GNUNET_HELLO_Builder* GST_my_hello

Our HELLO.

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

Referenced by do_shutdown(), feed_addresses_to_pils(), handle_add_address(), handle_del_address(), peerstore_store_own_cb(), pils_pid_change_cb(), pils_sign_hello_cb(), run(), and store_pi().

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 3199 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(), start_dv_learn(), and transmit_dv_init().

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

Referenced by decaps_dv_box_cont(), detach_cmcs_from_client(), do_shutdown(), free_backtalker(), 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 3211 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 3217 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 3223 of file gnunet-service-transport.c.

Referenced by consider_sending_fc(), 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 3229 of file gnunet-service-transport.c.

Referenced by do_shutdown(), free_validation_state(), handle_add_queue_message(), handle_validation_response(), run(), start_address_validation(), and try_to_bring_link_up().

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

Referenced by activate_core_visible_dv_path(), detach_cmcs_from_client(), do_shutdown(), free_virtual_link(), handle_client_start(), handle_flow_control(), handle_link_list_request(), handle_validation_response(), load_message_store_links(), lookup_virtual_link(), and run().

dvlearn_map

struct GNUNET_CONTAINER_MultiShortmap* dvlearn_map

static

Map from challenges to struct LearnLaunchEntry values.

Definition at line 3246 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 3251 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 3256 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 3263 of file gnunet-service-transport.c.

Referenced by do_shutdown(), run(), update_next_challenge_time(), and validation_start_cb().

nh

struct GNUNET_NAT_Handle* nh

Handle for connect to the NAT service.

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

Referenced by do_shutdown(), handle_flow_control(), and run().

peerstore

struct GNUNET_PEERSTORE_Handle* peerstore

static

Database for peer's HELLOs.

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

Referenced by decaps_dv_box_cont(), do_shutdown(), handle_add_queue_message(), handle_dv_learn(), handle_validation_response(), pils_pid_change_cb(), pils_sign_hello_cb(), queue_burst(), run(), store_signed_address(), and update_backtalker_monotime().

pils

struct GNUNET_PILS_Handle* pils

static

Service that manages our peer id.

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

Referenced by check_dv_box(), check_dv_learn(), decaps_dv_box_cont(), do_shutdown(), encapsulate_for_dv(), feed_addresses_to_pils(), forward_dv_learn(), handle_backchannel_encapsulation(), handle_communicator_available(), handle_dv_box(), handle_dv_learn(), handle_hello_for_client(), handle_hello_for_incoming(), handle_suggest(), learn_dv_path(), peerstore_store_own_cb(), pils_pid_change_cb(), pils_sign_address(), run(), sign_by_my_identity(), start_dv_learn(), and store_pi().

pils_requests_head

struct PilsRequest* pils_requests_head

static

PILS Operation DLL.

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

Referenced by cancel_address_store(), do_shutdown(), peerstore_store_own_cb(), and pils_sign_hello_cb().

pils_requests_tail

struct PilsRequest* pils_requests_tail

static

PILS Operation DLL.

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

Referenced by cancel_address_store(), do_shutdown(), peerstore_store_own_cb(), and pils_sign_hello_cb().

dvlearn_task

struct GNUNET_SCHEDULER_Task* dvlearn_task

static

Task run to initiate DV learning.

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

Referenced by do_shutdown(), handle_add_queue_message(), start_dv_learn(), and transmit_dv_init().

dvlearn_pils_backoff

struct GNUNET_TIME_Relative dvlearn_pils_backoff

static

Backoff for start_dv_learn() while PILS still owes us an identity.

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

Referenced by start_dv_learn().

validation_task

struct GNUNET_SCHEDULER_Task* validation_task

static

Task to run address validation.

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

Referenced by do_shutdown(), update_next_challenge_time(), and validation_start_cb().

pils_feed_task

struct GNUNET_SCHEDULER_Task* pils_feed_task

static

Task to feed addresses to PILS.

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

Referenced by do_shutdown(), feed_addresses_to_pils(), handle_add_address(), and handle_del_address().

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

Referenced by do_shutdown(), free_incoming_request(), and try_to_bring_link_up().

ir_tail

struct IncomingRequest* ir_tail

static

Tail of DLL starting at ir_head.

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

Referenced by free_incoming_request(), and try_to_bring_link_up().

ir_total

unsigned int ir_total

static

Length of the DLL starting at ir_head.

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

Referenced by do_shutdown(), free_incoming_request(), and try_to_bring_link_up().

logging_uuid_gen

unsigned long long logging_uuid_gen

static

Generator of logging_uuid in struct PendingMessage.

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

Referenced by burst_timeout(), do_shutdown(), 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 3413 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 3419 of file gnunet-service-transport.c.

Referenced by client_disconnect_cb(), run(), shutdown_task(), start_dv_learn(), store_pi(), and try_to_bring_link_up().

burst_task

struct GNUNET_SCHEDULER_Task* burst_task

static

The task to start the burst.

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

Referenced by do_shutdown(), free_burst_cls(), queue_burst(), and start_burst().

burst_task_cls

struct GNUNET_StartBurstCls* burst_task_cls

static

Closure of the currently scheduled burst_task, or NULL.

Needed so that we can release it (and only it) when the task is cancelled or when the struct VirtualLink it refers to goes away.

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

Referenced by free_burst_cls(), queue_burst(), and start_burst().

burst_timeout_task

struct GNUNET_SCHEDULER_Task* burst_timeout_task

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

Referenced by do_shutdown(), and start_burst().

use_burst

enum GNUNET_GenericReturnValue use_burst

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

Referenced by queue_burst(), and run().