The Reliability Layer is part of OpenVPN's control channel. More...

Data Structures
struct	reliable_ack
	The acknowledgment structure in which packet IDs are stored for later acknowledgment. More...
struct	reliable_entry
	The structure in which the reliability layer stores a single incoming or outgoing packet. More...
struct	reliable
	The reliability layer storage structure for one VPN tunnel's control channel in one direction. More...

Macros
#define	RELIABLE_ACK_SIZE 8
	The maximum number of packet IDs waiting to be acknowledged which can be stored in one `reliable_ack` structure.
#define	RELIABLE_CAPACITY 12
	The maximum number of packets that the reliability layer for one VPN tunnel in one direction can store.
#define	N_ACK_RETRANSMIT 3
	We retry sending a packet early if this many later packets have been ACKed.
#define	RELIABLE_MAX_TIMEOUT_SHIFT 6
	Maximum shift or doubling in exponential backoff we allow.
#define	RELIABLE_MAX_INITIAL_TIMEOUT (1 << 16)
	Maximum initial timeout (–tls-timeout) we accept.
#define	ACK_SIZE(n)

Functions for processing incoming acknowledgments
bool	reliable_ack_read (struct reliable_ack ack, struct buffer buf, const struct session_id *sid)
	Read an acknowledgment record from a received packet.
bool	reliable_ack_parse (struct buffer buf, struct reliable_ack ack, struct session_id *session_id_remote)
	Parse an acknowledgment record from a received packet.
void	reliable_send_purge (struct reliable rel, const struct reliable_ack ack)
	Remove acknowledged packets from a reliable structure.

Functions for processing outgoing acknowledgments
static bool	reliable_ack_empty (const struct reliable_ack *ack)
	Check whether an acknowledgment structure contains any packet IDs to be acknowledged.
bool	reliable_pid_in_send_window (const struct reliable *rel, packet_id_type pid)
	Check whether pid is one of the RELIABLE_CAPACITY ids below rel->packet_id, and so could still be outstanding.
static int	reliable_ack_outstanding (const struct reliable_ack *ack)
	Returns the number of packets that need to be acked.
bool	reliable_ack_write (struct reliable_ack ack, struct reliable_ack ack_mru, struct buffer buf, const struct session_id sid, int max, bool prepend)
	Write a packet ID acknowledgment record to a buffer.

Functions for initialization and cleanup
void	reliable_init (struct reliable *rel, int buf_size, int offset, int array_size, bool hold)
	Initialize a reliable structure.
void	reliable_free (struct reliable *rel)
	Free allocated memory associated with a reliable structure and the pointer itself.

Functions for inserting incoming packets
bool	reliable_can_get (const struct reliable *rel)
	Check whether a reliable structure has any free buffers available for use.
bool	reliable_not_replay (const struct reliable *rel, packet_id_type id)
	Check that a received packet's ID is not a replay and is inside the receive window.
bool	reliable_wont_break_sequentiality (const struct reliable *rel, packet_id_type id)
	Check that a received packet's ID can safely be stored in the reliable structure's processing window.
bool	reliable_ack_read_packet_id (struct buffer buf, packet_id_type pid)
	Read the packet ID of a received packet.
struct buffer *	reliable_get_buf (struct reliable *rel)
	Get the buffer of a free reliable entry in which to store a packet.
void	reliable_mark_active_incoming (struct reliable rel, const struct buffer buf, packet_id_type pid, int opcode)
	Mark the reliable entry associated with the given buffer as active incoming.
bool	reliable_ack_acknowledge_packet_id (struct reliable_ack *ack, packet_id_type pid)
	Record a packet ID for later acknowledgment.

Functions for extracting incoming packets
struct reliable_entry *	reliable_get_entry_sequenced (struct reliable *rel)
	Get the buffer of the next sequential and active entry.
void	copy_acks_to_mru (struct reliable_ack ack, struct reliable_ack ack_mru, int n)
	Copies the first n acks from `ack` to `ack_mru`.
void	reliable_mark_deleted (struct reliable rel, const struct buffer buf)
	Remove an entry from a reliable structure.

Functions for inserting outgoing packets
struct buffer *	reliable_get_buf_output_sequenced (struct reliable *rel)
	Get the buffer of free reliable entry and check whether the outgoing acknowledgment sequence is still okay.
int	reliable_get_num_output_sequenced_available (const struct reliable *rel)
	Counts the number of free buffers in output that can be potentially used for sending.
void	reliable_mark_active_outgoing (struct reliable rel, struct buffer buf, int opcode)
	Mark the reliable entry associated with the given buffer as active outgoing.

Functions for extracting outgoing packets
bool	reliable_can_send (const struct reliable *rel)
	Check whether a reliable structure has any active entries ready to be (re)sent.
struct buffer *	reliable_send (struct reliable rel, int opcode)
	Get the next packet to send to the remote peer.

Miscellaneous functions
bool	reliable_empty (const struct reliable *rel)
	Check whether a reliable structure is empty.
interval_t	reliable_send_timeout (const struct reliable *rel)
	Determined how many seconds until the earliest resend should be attempted.
void	reliable_schedule_now (struct reliable *rel)
	Reschedule all entries of a reliable structure to be ready for (re)sending immediately.
void	reliable_debug_print (const struct reliable rel, char desc)
static void	reliable_set_timeout (struct reliable *rel, interval_t timeout)
const char *	reliable_ack_print (struct buffer buf, bool verbose, struct gc_arena gc)
void	reliable_ack_debug_print (const struct reliable_ack ack, char desc)

Detailed Description

The Reliability Layer is part of OpenVPN's control channel.

It provides a reliable and sequential transport mechanism for control channel messages between OpenVPN peers. This module forms the interface between the External Multiplexer and the Control Channel TLS module.

UDP or TCP as VPN tunnel transport

This is especially important when OpenVPN is configured to communicate over UDP, because UDP does not offer a reliable and sequential transport. OpenVPN endpoints can also communicate over TCP which does provide a reliable and sequential transport. In both cases, using UDP or TCP as an external transport, the internal Reliability Layer is active.

Macro Definition Documentation

◆ ACK_SIZE

#define ACK_SIZE ( n )

Value:

(sizeof(uint8_t) + ((n) ? SID_SIZE : 0) + sizeof(packet_id_type) * (n))

packet_id_type

uint32_t packet_id_type

Definition packet_id.h:45

SID_SIZE

#define SID_SIZE

Definition session_id.h:44

Definition at line 81 of file reliable.h.

Referenced by calc_control_channel_frame_overhead(), init_frame_parameters(), reliable_ack_write(), and tls_init_control_channel_frame_parameters().

◆ N_ACK_RETRANSMIT

#define N_ACK_RETRANSMIT 3

We retry sending a packet early if this many later packets have been ACKed.

Definition at line 54 of file reliable.h.

Referenced by reliable_can_send(), reliable_send(), and test_reliable_backoff_is_bounded().

◆ RELIABLE_ACK_SIZE

#define RELIABLE_ACK_SIZE 8

The maximum number of packet IDs waiting to be acknowledged which can be stored in one reliable_ack structure.

Definition at line 43 of file reliable.h.

Referenced by copy_acks_to_mru(), init_frame_parameters(), reliable_ack_acknowledge_packet_id(), reliable_ack_parse(), tls_init_control_channel_frame_parameters(), and tls_process().

◆ RELIABLE_CAPACITY

#define RELIABLE_CAPACITY 12

The maximum number of packets that the reliability layer for one VPN tunnel in one direction can store.

Definition at line 49 of file reliable.h.

Referenced by ref_pid_in_send_window(), reliable_init(), reliable_pid_in_send_window(), sweep_recv_filter(), test_mark_active_incoming_accepts_window(), test_mark_active_incoming_rejects_past_ids(), test_packet_id_window(), test_recv_window_bounded_at_wrap(), and test_wont_break_sequentiality_accepts_next_id().

◆ RELIABLE_MAX_INITIAL_TIMEOUT

#define RELIABLE_MAX_INITIAL_TIMEOUT (1 << 16)

Maximum initial timeout (–tls-timeout) we accept.

Bounded so that shifting it by RELIABLE_MAX_TIMEOUT_SHIFT cannot overflow an int.

Definition at line 65 of file reliable.h.

Referenced by add_option(), and reliable_send().

◆ RELIABLE_MAX_TIMEOUT_SHIFT

#define RELIABLE_MAX_TIMEOUT_SHIFT 6

Maximum shift or doubling in exponential backoff we allow.

This is a safeguard against an unbounded exponential backoff. With the default timeout of 2s this equals 128s

Definition at line 59 of file reliable.h.

Referenced by reliable_send().

Function Documentation

◆ copy_acks_to_mru()

void copy_acks_to_mru	(	struct reliable_ack *	ack,
		struct reliable_ack *	ack_mru,
		int	n )

Copies the first n acks from ack to ack_mru.

Parameters

ack	The reliable structure to copy the acks from
ack_mru	The reliable structure to insert the acks into
n	The number of ACKS to copy

Definition at line 171 of file reliable.c.

References ASSERT, reliable_ack::len, reliable_ack::packet_id, and RELIABLE_ACK_SIZE.

Referenced by reliable_ack_write(), and test_copy_acks_to_lru().

◆ reliable_ack_acknowledge_packet_id()

bool reliable_ack_acknowledge_packet_id	(	struct reliable_ack *	ack,
		packet_id_type	pid )

Record a packet ID for later acknowledgment.

Parameters

ack	The acknowledgment structure which stores this VPN tunnel's packet IDs for later acknowledgment.
pid	The packet ID of the received packet which should be acknowledged.

Returns

True, if the packet ID was added to ack.
False, if the packet ID was already present in ack or ack has no free space to store any more packet IDs.

Definition at line 94 of file reliable.c.

References D_REL_DEBUG, D_REL_LOW, dmsg, reliable_ack::len, reliable_ack::packet_id, packet_id_format, reliable_ack_packet_id_present(), and RELIABLE_ACK_SIZE.

Referenced by tls_pre_decrypt().

◆ reliable_ack_debug_print()

void reliable_ack_debug_print	(	const struct reliable_ack *	ack,
		char *	desc )

◆ reliable_ack_empty()

bool reliable_ack_empty ( const struct reliable_ack * ack )

inlinestatic

Check whether an acknowledgment structure contains any packet IDs to be acknowledged.

Parameters

ack	The acknowledgment structure to check.

Returns

True, if the acknowledgment structure is empty.
False, if there are packet IDs to be acknowledged.

Definition at line 187 of file reliable.h.

References reliable_ack::len.

Referenced by tls_process().

◆ reliable_ack_outstanding()

int reliable_ack_outstanding ( const struct reliable_ack * ack )

inlinestatic

Returns the number of packets that need to be acked.

Parameters

ack	The acknowledgment structure to check.

Returns: the number of outstanding acks

Definition at line 216 of file reliable.h.

References reliable_ack::len.

Referenced by calc_control_channel_frame_overhead().

◆ reliable_ack_parse()

bool reliable_ack_parse	(	struct buffer *	buf,
		struct reliable_ack *	ack,
		struct session_id *	session_id_remote )

Parse an acknowledgment record from a received packet.

This function parses the packet ID acknowledgment record from the packet contained in buf. If the record contains acknowledgments, these are stored in ack. This function also extracts packet's session ID and returns it in session_id_remote

Parameters

ack	The acknowledgment structure in which received acknowledgments are to be stored.
buf	The buffer containing the packet.
session_id_remote	The parsed remote session id. This field is is only filled if ack->len >= 1

Returns

True, if processing was successful.
False, if an error occurs during processing.

Definition at line 133 of file reliable.c.

References buf_read(), reliable_ack::len, ntohpid, reliable_ack::packet_id, RELIABLE_ACK_SIZE, and session_id_read().

Referenced by check_session_hmac_and_pkt_id(), reliable_ack_read(), and test_parse_ack().

◆ reliable_ack_print()

const char * reliable_ack_print	(	struct buffer *	buf,
		bool	verbose,
		struct gc_arena *	gc )

Definition at line 272 of file reliable.c.

References alloc_buf_gc(), BSTR, buf_printf(), buf_read(), gc, ntohpid, packet_id_format, session_id_print(), and session_id_read().

Referenced by protocol_dump().

◆ reliable_ack_read()

bool reliable_ack_read	(	struct reliable_ack *	ack,
		struct buffer *	buf,
		const struct session_id *	sid )

Read an acknowledgment record from a received packet.

This function reads the packet ID acknowledgment record from the packet contained in buf. If the record contains acknowledgments, these are stored in ack. This function also compares the packet's session ID with the expected session ID sid, which should be equal.

Parameters

ack	The acknowledgment structure in which received acknowledgments are to be stored.
buf	The buffer containing the packet.
sid	The expected session ID to compare to the session ID in the packet.

Returns

True, if processing was successful.
False, if an error occurs during processing.

Definition at line 111 of file reliable.c.

References D_REL_LOW, dmsg, gc, gc_free(), gc_new(), reliable_ack::len, reliable_ack_parse(), session_id_defined(), session_id_equal(), and session_id_print().

Referenced by tls_pre_decrypt().

◆ reliable_ack_read_packet_id()

bool reliable_ack_read_packet_id	(	struct buffer *	buf,
		packet_id_type *	pid )

Read the packet ID of a received packet.

Parameters

buf	The buffer containing the received packet.
pid	A pointer where the packet's packet ID will be written.

Returns

True, if processing was successful.
False, if an error occurs during processing.

Definition at line 76 of file reliable.c.

References buf_read(), D_REL_DEBUG, D_REL_LOW, dmsg, buffer::len, ntohpid, and packet_id_format.

Referenced by check_session_hmac_and_pkt_id(), and tls_pre_decrypt().

◆ reliable_ack_write()

bool reliable_ack_write	(	struct reliable_ack *	ack,
		struct reliable_ack *	ack_mru,
		struct buffer *	buf,
		const struct session_id *	sid,
		int	max,
		bool	prepend )

Write a packet ID acknowledgment record to a buffer.

Parameters

ack	The acknowledgment structure containing packet IDs to be acknowledged.
ack_mru	List of packets we have acknowledged before. Packets from `ack` will be moved here and if there is space in our ack structure we will fill it with packets from this
buf	The buffer into which the acknowledgment record will be written.
sid	The session ID of the VPN tunnel associated with the packet IDs to be acknowledged.
max	The maximum number of acknowledgments to be written in the record.
prepend	If true, prepend the acknowledgment record in the buffer; if false, write into the buffer's current position.

Returns

True, if processing was successful.
False, if an error occurs during processing.

Definition at line 215 of file reliable.c.

References ACK_SIZE, ASSERT, BDEF, buf_sub(), buf_write(), buf_write_u8(), copy_acks_to_mru(), D_REL_DEBUG, dmsg, htonpid, reliable_ack::len, min_int(), reliable_ack::packet_id, packet_id_format, session_id_defined(), and session_id_write().

Referenced by write_control_auth().

◆ reliable_can_get()

bool reliable_can_get ( const struct reliable * rel )

Check whether a reliable structure has any free buffers available for use.

Parameters

rel	The reliable structure to check.

Returns

True, if at least one buffer is available for use.
False, if all the buffers are active.

Definition at line 457 of file reliable.c.

References reliable_entry::active, reliable::array, D_REL_LOW, dmsg, gc, gc_free(), gc_new(), reliable_print_ids(), and reliable::size.

Referenced by tls_pre_decrypt().

◆ reliable_can_send()

bool reliable_can_send ( const struct reliable * rel )

Check whether a reliable structure has any active entries ready to be (re)sent.

Parameters

rel	The reliable structure to check.

Returns

True, if there are active entries ready to be (re)sent president.
False, if there are no active entries, or the active entries are not yet ready for resending.

Definition at line 611 of file reliable.c.

References reliable_entry::active, reliable::array, D_REL_DEBUG, dmsg, gc, gc_free(), gc_new(), reliable::hold, N_ACK_RETRANSMIT, reliable_entry::n_acks, reliable_entry::next_try, now, reliable_print_ids(), and reliable::size.

Referenced by test_reliable_send_matches_can_send(), and tls_process_state().

◆ reliable_debug_print()

void reliable_debug_print	(	const struct reliable *	rel,
		char *	desc )

◆ reliable_empty()

bool reliable_empty ( const struct reliable * rel )

Check whether a reliable structure is empty.

Parameters

rel	The reliable structure to check.

Returns

True, if there are no active entries in the given reliable structure.
False, if there is at least one active entry present.

Definition at line 347 of file reliable.c.

References reliable_entry::active, reliable::array, and reliable::size.

Referenced by tls_process_state().

◆ reliable_free()

void reliable_free ( struct reliable * rel )

Free allocated memory associated with a reliable structure and the pointer itself.

Does nothing if rel is NULL.

Parameters

rel	The reliable structured to clean up.

Definition at line 331 of file reliable.c.

References reliable::array, reliable_entry::buf, free_buf(), and reliable::size.

Referenced by key_state_free(), test_get_buf_output_sequenced_boundary(), test_get_num_output_sequenced_available(), test_reliable_backoff_is_bounded(), test_reliable_purge_ignores_forged_acks(), and test_reliable_purge_legitimate_ack().

◆ reliable_get_buf()

struct buffer * reliable_get_buf ( struct reliable * rel )

Get the buffer of a free reliable entry in which to store a packet.

Parameters

rel	The reliable structure in which to search for a free entry.

Returns: A pointer to a buffer of a free entry in the rel reliable structure. If there are no free entries available, this function returns NULL.

Definition at line 528 of file reliable.c.

References reliable_entry::active, reliable::array, ASSERT, reliable_entry::buf, buf_init, reliable::offset, and reliable::size.

Referenced by reliable_get_buf_output_sequenced(), and tls_pre_decrypt().

◆ reliable_get_buf_output_sequenced()

struct buffer * reliable_get_buf_output_sequenced ( struct reliable * rel )

Get the buffer of free reliable entry and check whether the outgoing acknowledgment sequence is still okay.

Parameters

rel	The reliable structure in which to search for a free entry.

Returns: A pointer to a buffer of a free entry in the rel reliable structure. If there are no free entries available, this function returns NULL. If the outgoing acknowledgment sequence is broken, this function also returns NULL.

Definition at line 576 of file reliable.c.

References D_REL_LOW, dmsg, gc, gc_free(), gc_new(), reliable_get_buf(), reliable_oldest_active_distance(), reliable_print_ids(), and reliable::size.

Referenced by check_outgoing_ciphertext(), session_move_pre_start(), test_get_buf_output_sequenced_boundary(), tls_process(), and write_outgoing_tls_ciphertext().

◆ reliable_get_entry_sequenced()

struct reliable_entry * reliable_get_entry_sequenced ( struct reliable * rel )

Get the buffer of the next sequential and active entry.

Parameters

rel	The reliable structure from which to retrieve the buffer.

Returns: A pointer to the entry with the next sequential key ID. If no such entry is present, this function returns NULL.

Definition at line 596 of file reliable.c.

References reliable_entry::active, reliable::array, reliable::packet_id, reliable_entry::packet_id, and reliable::size.

Referenced by tls_process_state().

◆ reliable_get_num_output_sequenced_available()

int reliable_get_num_output_sequenced_available ( const struct reliable * rel )

Counts the number of free buffers in output that can be potentially used for sending.

Parameters

rel	The reliable structure in which to search for a free entry.

Returns: the number of buffer that are available for sending without breaking ack sequence

Definition at line 569 of file reliable.c.

References reliable_oldest_active_distance(), and reliable::size.

Referenced by test_get_num_output_sequenced_available(), and write_outgoing_tls_ciphertext().

◆ reliable_init()

void reliable_init	(	struct reliable *	rel,
		int	buf_size,
		int	offset,
		int	array_size,
		bool	hold )

Initialize a reliable structure.

Parameters

rel	The reliable structure to initialize.
buf_size	The size of the buffers in which packets will be stored.
offset	The size of reserved space at the beginning of the buffers to allow efficient header prepending.
array_size	The number of packets that this reliable structure can store simultaneously.
hold	description

Definition at line 315 of file reliable.c.

References alloc_buf(), reliable::array, ASSERT, reliable_entry::buf, buf_init, CLEAR, reliable::hold, reliable::offset, RELIABLE_CAPACITY, and reliable::size.

Referenced by key_state_init(), test_get_num_output_sequenced_available(), and test_reliable_new().

◆ reliable_mark_active_incoming()

void reliable_mark_active_incoming	(	struct reliable *	rel,
		const struct buffer *	buf,
		packet_id_type	pid,
		int	opcode )

Mark the reliable entry associated with the given buffer as active incoming.

pid must be less than rel->size ahead of rel->packet_id. This is asserted, so run reliable_wont_break_sequentiality() and reliable_not_replay() first.

Parameters

rel	The reliable structure associated with this packet.
buf	The buffer into which the packet has been copied.
pid	The packet's packet ID.
opcode	The packet's opcode.

Definition at line 755 of file reliable.c.

References reliable_entry::active, reliable::array, ASSERT, reliable_entry::buf, D_REL_DEBUG, dmsg, reliable_entry::n_acks, reliable_entry::next_try, reliable_entry::opcode, reliable::packet_id, reliable_entry::packet_id, packet_id_format, reliable_pid_in_range(), reliable::size, and reliable_entry::timeout.

Referenced by test_mark_active_incoming_accepts_window(), test_mark_active_incoming_rejects_past_ids(), and tls_pre_decrypt().

◆ reliable_mark_active_outgoing()

void reliable_mark_active_outgoing	(	struct reliable *	rel,
		struct buffer *	buf,
		int	opcode )

Mark the reliable entry associated with the given buffer as active outgoing.

Parameters

rel	The reliable structure for handling this VPN tunnel's outgoing packets.
buf	The buffer previously returned by `reliable_get_buf_output_sequenced()` into which the packet has been copied.
opcode	The packet's opcode.

Definition at line 788 of file reliable.c.

References reliable_entry::active, reliable::array, ASSERT, reliable_entry::buf, buf_write_prepend(), D_REL_DEBUG, dmsg, htonpid, reliable::initial_timeout, reliable_entry::next_try, reliable_entry::opcode, reliable::packet_id, reliable_entry::packet_id, packet_id_format, reliable::size, and reliable_entry::timeout.

Referenced by session_move_pre_start(), tls_process(), and write_outgoing_tls_ciphertext().

◆ reliable_mark_deleted()

void reliable_mark_deleted	(	struct reliable *	rel,
		const struct buffer *	buf )

Remove an entry from a reliable structure.

Parameters

rel	The reliable structure associated with the given buffer.
buf	The buffer of the reliable entry which is to be removed.

Definition at line 815 of file reliable.c.

References reliable_entry::active, reliable::array, ASSERT, reliable_entry::buf, reliable::packet_id, reliable_entry::packet_id, and reliable::size.

Referenced by parse_early_negotiation_tlvs(), read_incoming_tls_ciphertext(), and session_move_pre_start().

◆ reliable_not_replay()

bool reliable_not_replay	(	const struct reliable *	rel,
		packet_id_type	id )

Check that a received packet's ID is not a replay and is inside the receive window.

Parameters

rel	The reliable structure for handling this VPN tunnel's received packets.
id	The packet ID of the received packet.

Returns

True, if the packet ID is new and inside the receive window.
False, if it is a replay, or too far ahead to be stored.

Definition at line 475 of file reliable.c.

References reliable_entry::active, reliable::array, D_REL_DEBUG, dmsg, gc, gc_free(), gc_new(), reliable::packet_id, reliable_entry::packet_id, packet_id_format, reliable_pid_in_range(), reliable_print_ids(), and reliable::size.

Referenced by recv_filter(), test_wont_break_sequentiality_accepts_next_id(), and tls_pre_decrypt().

◆ reliable_pid_in_send_window()

bool reliable_pid_in_send_window	(	const struct reliable *	rel,
		packet_id_type	pid )

Check whether pid is one of the RELIABLE_CAPACITY ids below rel->packet_id, and so could still be outstanding.

rel->packet_id is the next id to be sent, so it is not itself in the window.

pid comes off the wire; all 2^32 values are handled.

Parameters

rel	The reliable structure holding this tunnel's sent packets.
pid	A packet ID from a received acknowledgment.

Returns

True, if pid is inside the window.
False, otherwise.

Definition at line 361 of file reliable.c.

References reliable::packet_id, RELIABLE_CAPACITY, reliable_pid_in_range(), and subtract_pid().

Referenced by reliable_send_purge(), sweep_send_window(), and test_packet_id_window().

◆ reliable_schedule_now()

void reliable_schedule_now ( struct reliable * rel )

Reschedule all entries of a reliable structure to be ready for (re)sending immediately.

Parameters

rel	The reliable structure of which the entries should be modified.

Definition at line 703 of file reliable.c.

References reliable_entry::active, reliable::array, D_REL_DEBUG, dmsg, reliable::hold, reliable::initial_timeout, reliable_entry::next_try, now, reliable::size, and reliable_entry::timeout.

Referenced by tls_pre_decrypt().

◆ reliable_send()

struct buffer * reliable_send	(	struct reliable *	rel,
		int *	opcode )

Get the next packet to send to the remote peer.

This function looks for the active entry ready for (re)sending with the lowest packet ID, and returns the buffer associated with it. This function also resets the timeout after which that entry will become ready for resending again.

Parameters

rel	The reliable structure to check.
opcode	A pointer to an integer in which this function will store the opcode of the next packet to be sent.

Returns: A pointer to the buffer of the next entry to be sent, or NULL if there are no entries ready for (re)sending present in the reliable structure. If a valid pointer is returned, then opcode will point to the opcode of that packet.

Definition at line 637 of file reliable.c.

References reliable_entry::active, reliable::array, reliable_entry::buf, D_REL_DEBUG, dmsg, reliable::initial_timeout, buffer::len, N_ACK_RETRANSMIT, reliable_entry::n_acks, reliable_entry::next_try, now, reliable_entry::opcode, reliable::packet_id, reliable_entry::packet_id, packet_id_format, RELIABLE_MAX_INITIAL_TIMEOUT, RELIABLE_MAX_TIMEOUT_SHIFT, reliable::size, subtract_pid(), and reliable_entry::timeout.

Referenced by test_reliable_backoff_is_bounded(), test_reliable_send_ignores_entry_ahead(), test_reliable_send_matches_can_send(), test_reliable_send_picks_oldest(), and tls_process_state().

◆ reliable_send_purge()

void reliable_send_purge	(	struct reliable *	rel,
		const struct reliable_ack *	ack )

Remove acknowledged packets from a reliable structure.

Parameters

rel	The reliable structure storing sent packets.
ack	The acknowledgment structure containing received acknowledgments.

Definition at line 369 of file reliable.c.

References reliable_entry::active, reliable::array, D_REL_DEBUG, D_REL_LOW, dmsg, reliable_ack::len, M_INFO, msg, reliable_entry::n_acks, reliable_entry::next_try, now, reliable::packet_id, reliable_ack::packet_id, reliable_entry::packet_id, packet_id_format, reliable_pid_in_send_window(), reliable::size, and subtract_pid().

Referenced by test_reliable_purge_ignores_forged_acks(), test_reliable_purge_legitimate_ack(), and tls_pre_decrypt().

◆ reliable_send_timeout()

interval_t reliable_send_timeout ( const struct reliable * rel )

Determined how many seconds until the earliest resend should be attempted.

Parameters

rel	The reliable structured to check.

Returns: The interval in seconds until the earliest resend attempt of the outgoing packets stored in the rel reliable structure. If the next time for attempting resending of one or more packets has already passed, this function will return 0.

Definition at line 721 of file reliable.c.

References reliable_entry::active, reliable::array, BIG_TIMEOUT, D_REL_DEBUG, dmsg, gc, gc_free(), gc_new(), min_int(), reliable_entry::next_try, now, reliable_print_ids(), and reliable::size.

Referenced by tls_process().

◆ reliable_set_timeout()

void reliable_set_timeout	(	struct reliable *	rel,
		interval_t	timeout )

inlinestatic

Definition at line 559 of file reliable.h.

References reliable::initial_timeout.

Referenced by key_state_init().

◆ reliable_wont_break_sequentiality()

bool reliable_wont_break_sequentiality	(	const struct reliable *	rel,
		packet_id_type	id )

Check that a received packet's ID can safely be stored in the reliable structure's processing window.

Checks the received packet's ID against rel->packet_id, the next ID the reliability layer expects to hand upwards. One too far ahead could fill the structure without leaving room for the intervening packets, so it is discarded.

IDs numerically below rel->packet_id are accepted here, an absolute comparison that an ID from before a wraparound does not pass. reliable_not_replay() rejects them, and they are still acknowledged so a peer whose ACK was lost stops retransmitting.

Parameters

rel	The reliable structure for handling this VPN tunnel's received packets.
id	The packet ID of the received packet.

Returns

True, if the packet can safely be stored.
False, if the packet does not fit safely in the reliable structure's processing window.

Definition at line 504 of file reliable.c.

References D_REL_DEBUG, D_REL_LOW, dmsg, gc, gc_free(), gc_new(), reliable::packet_id, packet_id_format, reliable_print_ids(), reliable::size, and subtract_pid().

Referenced by recv_filter(), test_wont_break_sequentiality_accepts_next_id(), and tls_pre_decrypt().

Data Structures

Macros

Functions for processing incoming acknowledgments

Functions for processing outgoing acknowledgments

Functions for initialization and cleanup

Functions for inserting incoming packets

Functions for extracting incoming packets

Functions for inserting outgoing packets

Functions for extracting outgoing packets

Miscellaneous functions

Detailed Description

Macro Definition Documentation

◆ ACK_SIZE

◆ N_ACK_RETRANSMIT

◆ RELIABLE_ACK_SIZE

◆ RELIABLE_CAPACITY

◆ RELIABLE_MAX_INITIAL_TIMEOUT

◆ RELIABLE_MAX_TIMEOUT_SHIFT

Function Documentation

◆ copy_acks_to_mru()

◆ reliable_ack_acknowledge_packet_id()

◆ reliable_ack_debug_print()

◆ reliable_ack_empty()

◆ reliable_ack_outstanding()

◆ reliable_ack_parse()

◆ reliable_ack_print()

◆ reliable_ack_read()

◆ reliable_ack_read_packet_id()

◆ reliable_ack_write()

◆ reliable_can_get()

◆ reliable_can_send()

◆ reliable_debug_print()

◆ reliable_empty()

◆ reliable_free()

◆ reliable_get_buf()

◆ reliable_get_buf_output_sequenced()

◆ reliable_get_entry_sequenced()

◆ reliable_get_num_output_sequenced_available()

◆ reliable_init()

◆ reliable_mark_active_incoming()

◆ reliable_mark_active_outgoing()

◆ reliable_mark_deleted()

◆ reliable_not_replay()

◆ reliable_pid_in_send_window()

◆ reliable_schedule_now()

◆ reliable_send()

◆ reliable_send_purge()

◆ reliable_send_timeout()

◆ reliable_set_timeout()

◆ reliable_wont_break_sequentiality()