reliable.h

Go to the documentation of this file.

/*
 *  OpenVPN -- An application to securely tunnel IP networks
 *             over a single UDP port, with support for SSL/TLS-based
 *             session authentication and key exchange,
 *             packet encryption, packet authentication, and
 *             packet compression.
 *
 *  Copyright (C) 2002-2026 OpenVPN Inc <sales@openvpn.net>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, see <https://www.gnu.org/licenses/>.
 */
 
 
#ifndef RELIABLE_H
#define RELIABLE_H
 
#include "basic.h"
#include "buffer.h"
#include "packet_id.h"
#include "session_id.h"
#include "mtu.h"
 
#define RELIABLE_ACK_SIZE 8
#define RELIABLE_CAPACITY 12
#define N_ACK_RETRANSMIT 3
#define RELIABLE_MAX_TIMEOUT_SHIFT 6
#define RELIABLE_MAX_INITIAL_TIMEOUT (1 << 16)
struct reliable_ack
{
    int len;
    packet_id_type packet_id[RELIABLE_ACK_SIZE];
};
 
/* The size of the ACK header */
#define ACK_SIZE(n) (sizeof(uint8_t) + ((n) ? SID_SIZE : 0) + sizeof(packet_id_type) * (n))
 
struct reliable_entry
{
    bool active;
    interval_t timeout;
    time_t next_try;
    packet_id_type packet_id;
    size_t n_acks; /* Number of acks received for packets with higher PID.
                    * Used for fast retransmission when there were at least
                    * N_ACK_RETRANSMIT. */
    int opcode;
    struct buffer buf;
};
 
struct reliable
{
    int size;
    interval_t initial_timeout;
    packet_id_type packet_id; 
    int offset;               
    bool hold;                /* don't xmit until reliable_schedule_now is called */
    struct reliable_entry array[RELIABLE_CAPACITY];
};
 
 
/**************************************************************************/
bool reliable_ack_read(struct reliable_ack *ack, struct buffer *buf, const struct session_id *sid);
 
 
bool reliable_ack_parse(struct buffer *buf, struct reliable_ack *ack,
                        struct session_id *session_id_remote);
 
void reliable_send_purge(struct reliable *rel, const struct reliable_ack *ack);
 
/**************************************************************************/
static inline bool
reliable_ack_empty(struct reliable_ack *ack)
{
    return !ack->len;
}
 
int
validate_packet_id_window(struct reliable *rel, packet_id_type pid);
 
static inline int
reliable_ack_outstanding(struct reliable_ack *ack)
{
    return ack->len;
}
 
 
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);
 
/**************************************************************************/
void reliable_init(struct reliable *rel, int buf_size, int offset, int array_size, bool hold);
 
void reliable_free(struct reliable *rel);
 
/**************************************************************************/
bool reliable_can_get(const struct reliable *rel);
 
bool reliable_not_replay(const struct reliable *rel, packet_id_type id);
 
bool reliable_wont_break_sequentiality(const struct reliable *rel, packet_id_type id);
 
bool reliable_ack_read_packet_id(struct buffer *buf, packet_id_type *pid);
 
struct buffer *reliable_get_buf(struct reliable *rel);
 
void reliable_mark_active_incoming(struct reliable *rel, struct buffer *buf, packet_id_type pid,
                                   int opcode);
 
bool reliable_ack_acknowledge_packet_id(struct reliable_ack *ack, packet_id_type pid);
 
/**************************************************************************/
struct reliable_entry *reliable_get_entry_sequenced(struct reliable *rel);
 
 
void copy_acks_to_mru(struct reliable_ack *ack, struct reliable_ack *ack_mru, int n);
 
 
void reliable_mark_deleted(struct reliable *rel, struct buffer *buf);
 
/**************************************************************************/
struct buffer *reliable_get_buf_output_sequenced(struct reliable *rel);
 
 
int reliable_get_num_output_sequenced_available(struct reliable *rel);
 
void reliable_mark_active_outgoing(struct reliable *rel, struct buffer *buf, int opcode);
 
/**************************************************************************/
bool reliable_can_send(const struct reliable *rel);
 
struct buffer *reliable_send(struct reliable *rel, int *opcode);
 
/**************************************************************************/
bool reliable_empty(const struct reliable *rel);
 
interval_t reliable_send_timeout(const struct reliable *rel);
 
void reliable_schedule_now(struct reliable *rel);
 
void reliable_debug_print(const struct reliable *rel, char *desc);
 
/* set sending timeout (after this time we send again until ACK) */
static inline void
reliable_set_timeout(struct reliable *rel, interval_t timeout)
{
    rel->initial_timeout = timeout;
}
 
/* print a reliable ACK record coming off the wire */
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);
 
#endif /* RELIABLE_H */