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-2024 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, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#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 */