fragment.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-2025 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 FRAGMENT_H
#define FRAGMENT_H
 
#ifdef ENABLE_FRAGMENT
 
#include "common.h"
#include "buffer.h"
#include "interval.h"
#include "mtu.h"
#include "shaper.h"
#include "error.h"
 
 
#define N_FRAG_BUF 25
#define FRAG_TTL_SEC 10
#define FRAG_WAKEUP_INTERVAL 5
/**************************************************************************/
struct fragment
{
    bool defined;      
    int max_frag_size; 
#define FRAG_MAP_MASK 0xFFFFFFFF
#define MAX_FRAGS     32 
    unsigned int map;
    time_t timestamp;  
    struct buffer buf; 
};
 
 
struct fragment_list
{
    int seq_id;
    int index;
 
    struct fragment fragments[N_FRAG_BUF];
};
 
 
struct fragment_master
{
    struct event_timeout wakeup; 
#define N_SEQ_ID 256
    int outgoing_seq_id;        
#define MAX_FRAG_PKT_SIZE 65536 
    int outgoing_frag_size;     
    int outgoing_frag_id;       
    struct buffer outgoing;     
    struct buffer outgoing_return;
    struct fragment_list incoming;
};
 
 
/**************************************************************************/
 
typedef uint32_t fragment_header_type;
#define hton_fragment_header_type(x) htonl(x)
#define ntoh_fragment_header_type(x) ntohl(x)
#define FRAG_TYPE_MASK  0x00000003 
#define FRAG_TYPE_SHIFT 0          
#define FRAG_WHOLE       0         
#define FRAG_YES_NOTLAST 1
#define FRAG_YES_LAST    2
#define FRAG_TEST        3
#define FRAG_SEQ_ID_MASK  0x000000ff 
#define FRAG_SEQ_ID_SHIFT 2          
#define FRAG_ID_MASK  0x0000001f     
#define FRAG_ID_SHIFT 10             
/*
 * FRAG_SIZE  14 bits
 *
 * IF FRAG_YES_LAST (FRAG_SIZE):
 *   The max size of a %fragment.  If a %fragment is not the last %fragment in the packet,
 *   then the %fragment size is guaranteed to be equal to the max %fragment size.  Therefore,
 *   max_frag_size is only sent over the wire if FRAG_LAST is set.  Otherwise it is assumed
 *   to be the actual %fragment size received.
 */
#define FRAG_SIZE_MASK        0x00003fff 
#define FRAG_SIZE_SHIFT       15         
#define FRAG_SIZE_ROUND_SHIFT 2          
#define FRAG_SIZE_ROUND_MASK  ((1 << FRAG_SIZE_ROUND_SHIFT) - 1)
/*
 * FRAG_EXTRA 16 bits
 *
 * IF FRAG_WHOLE or FRAG_YES_NOTLAST, these 16 bits are available (not currently used)
 */
#define FRAG_EXTRA_MASK  0x0000ffff 
#define FRAG_EXTRA_SHIFT 15         
 
 
/**************************************************************************/
 
struct fragment_master *fragment_init(struct frame *frame);
 
 
void fragment_frame_init(struct fragment_master *f, const struct frame *frame);
 
 
void fragment_free(struct fragment_master *f);
 
 
 
/**************************************************************************/
void fragment_incoming(struct fragment_master *f, struct buffer *buf, const struct frame *frame);
 
/**************************************************************************/
void fragment_outgoing(struct fragment_master *f, struct buffer *buf, const struct frame *frame);
 
bool fragment_ready_to_send(struct fragment_master *f, struct buffer *buf,
                            const struct frame *frame);
 
static inline bool
fragment_outgoing_defined(struct fragment_master *f)
{
    return f->outgoing.len > 0;
}
 
void fragment_wakeup(struct fragment_master *f, struct frame *frame);
 
 
/**************************************************************************/
 
static inline void
fragment_housekeeping(struct fragment_master *f, struct frame *frame, struct timeval *tv)
{
    if (event_timeout_trigger(&f->wakeup, tv, ETT_DEFAULT))
    {
        fragment_wakeup(f, frame);
    }
}
 
 
 
 
 
#endif /* ifdef ENABLE_FRAGMENT */
#endif /* ifndef FRAGMENT_H */