OpenVPN
reliable.h
Go to the documentation of this file.
1 /*
2  * OpenVPN -- An application to securely tunnel IP networks
3  * over a single UDP port, with support for SSL/TLS-based
4  * session authentication and key exchange,
5  * packet encryption, packet authentication, and
6  * packet compression.
7  *
8  * Copyright (C) 2002-2017 OpenVPN Technologies, Inc. <sales@openvpn.net>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2
12  * as published by the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write to the Free Software Foundation, Inc.,
21  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22  */
23 
24 
31 #ifdef ENABLE_CRYPTO
32 
33 #ifndef RELIABLE_H
34 #define RELIABLE_H
35 
36 #include "basic.h"
37 #include "buffer.h"
38 #include "packet_id.h"
39 #include "session_id.h"
40 #include "mtu.h"
41 
46 #define EXPONENTIAL_BACKOFF
47 
48 #define RELIABLE_ACK_SIZE 8
53 #define RELIABLE_CAPACITY 8
61 struct reliable_ack
62 {
63  int len;
65 };
66 
71 struct reliable_entry
72 {
73  bool active;
75  time_t next_try;
77  int opcode;
78  struct buffer buf;
79 };
80 
85 struct reliable
86 {
87  int size;
88  interval_t initial_timeout;
90  int offset;
91  bool hold; /* don't xmit until reliable_schedule_now is called */
93 };
94 
95 
96 /**************************************************************************/
118 bool reliable_ack_read(struct reliable_ack *ack,
119  struct buffer *buf, const struct session_id *sid);
120 
128 void reliable_send_purge(struct reliable *rel, struct reliable_ack *ack);
129 
133 /**************************************************************************/
147 static inline bool
148 reliable_ack_empty(struct reliable_ack *ack)
149 {
150  return !ack->len;
151 }
152 
171 bool reliable_ack_write(struct reliable_ack *ack,
172  struct buffer *buf,
173  const struct session_id *sid, int max, bool prepend);
174 
178 /**************************************************************************/
194 void reliable_init(struct reliable *rel, int buf_size, int offset, int array_size, bool hold);
195 
201 void reliable_free(struct reliable *rel);
202 
203 /* add to extra_frame the maximum number of bytes we will need for reliable_ack_write */
204 void reliable_ack_adjust_frame_parameters(struct frame *frame, int max);
205 
209 /**************************************************************************/
223 bool reliable_can_get(const struct reliable *rel);
224 
236 bool reliable_not_replay(const struct reliable *rel, packet_id_type id);
237 
260 bool reliable_wont_break_sequentiality(const struct reliable *rel, packet_id_type id);
261 
273 
285 struct buffer *reliable_get_buf(struct reliable *rel);
286 
296 void reliable_mark_active_incoming(struct reliable *rel, struct buffer *buf,
297  packet_id_type pid, int opcode);
298 
313 
317 /**************************************************************************/
331 struct buffer *reliable_get_buf_sequenced(struct reliable *rel);
332 
341 void reliable_mark_deleted(struct reliable *rel, struct buffer *buf, bool inc_pid);
342 
346 /**************************************************************************/
363 
375 void reliable_mark_active_outgoing(struct reliable *rel, struct buffer *buf, int opcode);
376 
380 /**************************************************************************/
396 bool reliable_can_send(const struct reliable *rel);
397 
415 struct buffer *reliable_send(struct reliable *rel, int *opcode);
416 
420 /**************************************************************************/
434 bool reliable_empty(const struct reliable *rel);
435 
447 interval_t reliable_send_timeout(const struct reliable *rel);
448 
456 void reliable_schedule_now(struct reliable *rel);
457 
458 void reliable_debug_print(const struct reliable *rel, char *desc);
459 
460 /* set sending timeout (after this time we send again until ACK) */
461 static inline void
463 {
464  rel->initial_timeout = timeout;
465 }
466 
467 /* print a reliable ACK record coming off the wire */
468 const char *reliable_ack_print(struct buffer *buf, bool verbose, struct gc_arena *gc);
469 
470 void reliable_ack_debug_print(const struct reliable_ack *ack, char *desc);
471 
478 #endif /* RELIABLE_H */
479 #endif /* ENABLE_CRYPTO */
void reliable_free(struct reliable *rel)
Free allocated memory associated with a reliable structure.
Definition: reliable.c:329
interval_t initial_timeout
Definition: reliable.h:93
Packet geometry parameters.
Definition: mtu.h:93
#define RELIABLE_ACK_SIZE
The maximum number of packet IDs waiting to be acknowledged which can be stored in one reliable_ack s...
Definition: reliable.h:48
int opcode
Definition: reliable.h:82
void reliable_debug_print(const struct reliable *rel, char *desc)
bool reliable_empty(const struct reliable *rel)
Check whether a reliable structure is empty.
Definition: reliable.c:341
void reliable_send_purge(struct reliable *rel, struct reliable_ack *ack)
Remove acknowledged packets from a reliable structure.
Definition: reliable.c:357
struct buffer * reliable_get_buf(struct reliable *rel)
Get the buffer of a free reliable entry in which to store a packet.
Definition: reliable.c:475
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.
Definition: reliable.c:722
static void reliable_set_timeout(struct reliable *rel, interval_t timeout)
Definition: reliable.h:467
bool reliable_ack_write(struct reliable_ack *ack, struct buffer *buf, const struct session_id *sid, int max, bool prepend)
Write a packet ID acknowledgment record to a buffer.
Definition: reliable.c:215
void reliable_ack_adjust_frame_parameters(struct frame *frame, int max)
Definition: reliable.c:260
bool reliable_not_replay(const struct reliable *rel, packet_id_type id)
Check that a received packet&#39;s ID is not a replay.
Definition: reliable.c:428
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...
Definition: reliable.c:492
const char * reliable_ack_print(struct buffer *buf, bool verbose, struct gc_arena *gc)
Definition: reliable.c:267
bool active
Definition: reliable.h:78
interval_t reliable_send_timeout(const struct reliable *rel)
Determined how many seconds until the earliest resend should be attempted.
Definition: reliable.c:653
static bool reliable_ack_empty(struct reliable_ack *ack)
Check whether an acknowledgment structure contains any packet IDs to be acknowledged.
Definition: reliable.h:153
struct buffer buf
Definition: reliable.h:83
packet_id_type packet_id
Definition: reliable.h:81
void reliable_ack_debug_print(const struct reliable_ack *ack, char *desc)
#define RELIABLE_CAPACITY
The maximum number of packets that the reliability layer for one VPN tunnel in one direction can stor...
Definition: reliable.h:56
bool reliable_wont_break_sequentiality(const struct reliable *rel, packet_id_type id)
Check that a received packet&#39;s ID can safely be stored in the reliable structure&#39;s processing window...
Definition: reliable.c:455
struct buffer * reliable_get_buf_sequenced(struct reliable *rel)
Get the buffer of the next sequential and active entry.
Definition: reliable.c:528
time_t next_try
Definition: reliable.h:80
struct buffer * reliable_send(struct reliable *rel, int *opcode)
Get the next packet to send to the remote peer.
Definition: reliable.c:596
void reliable_mark_deleted(struct reliable *rel, struct buffer *buf, bool inc_pid)
Remove an entry from a reliable structure.
Definition: reliable.c:749
The structure in which the reliability layer stores a single incoming or outgoing packet...
Definition: reliable.h:76
The acknowledgment structure in which packet IDs are stored for later acknowledgment.
Definition: reliable.h:66
Wrapper structure for dynamically allocated memory.
Definition: buffer.h:60
bool reliable_ack_read_packet_id(struct buffer *buf, packet_id_type *pid)
Read the packet ID of a received packet.
Definition: reliable.c:125
bool reliable_can_send(const struct reliable *rel)
Check whether a reliable structure has any active entries ready to be (re)sent.
Definition: reliable.c:544
void reliable_init(struct reliable *rel, int buf_size, int offset, int array_size, bool hold)
Initialize a reliable structure.
Definition: reliable.c:311
The reliability layer storage structure for one VPN tunnel&#39;s control channel in one direction...
Definition: reliable.h:90
uint32_t packet_id_type
Definition: packet_id.h:51
bool reliable_can_get(const struct reliable *rel)
Check whether a reliable structure has any free buffers available for use.
Definition: reliable.c:409
Garbage collection arena used to keep track of dynamically allocated memory.
Definition: buffer.h:116
bool reliable_ack_read(struct reliable_ack *ack, struct buffer *buf, const struct session_id *sid)
Read an acknowledgment record from a received packet.
Definition: reliable.c:160
int interval_t
Definition: common.h:45
void reliable_mark_active_incoming(struct reliable *rel, struct buffer *buf, packet_id_type pid, int opcode)
Mark the reliable entry associated with the given buffer as active incoming.
Definition: reliable.c:690
interval_t timeout
Definition: reliable.h:79
void reliable_schedule_now(struct reliable *rel)
Reschedule all entries of a reliable structure to be ready for (re)sending immediately.
Definition: reliable.c:634
bool reliable_ack_acknowledge_packet_id(struct reliable_ack *ack, packet_id_type pid)
Record a packet ID for later acknowledgment.
Definition: reliable.c:143