release/src/router/openvpn/mtu.h

   1 /*
   2  *  OpenVPN -- An application to securely tunnel IP networks
   3  *             over a single TCP/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-2009 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
  20  *  along with this program (see the file COPYING included with this
  21  *  distribution); if not, write to the Free Software Foundation, Inc.,
  22  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #ifndef MTU_H
  26 #define MTU_H
  27
  28 #include "buffer.h"
  29
  30 /*
  31  *
  32  * Packet maninipulation routes such as encrypt, decrypt, compress, decompress
  33  * are passed a frame buffer that looks like this:
  34  *
  35  *    [extra_frame bytes] [mtu bytes] [extra_frame_bytes] [compression overflow bytes]
  36  *                         ^
  37  *                   Pointer passed to function points here so that routine
  38  *                   can make use of extra_frame bytes before pointer
  39  *                   to prepend headers, etc.
  40  *
  41  *    extra_frame bytes is large enough for all encryption related overhead.
  42  *
  43  *    mtu bytes will be the MTU size set in the ifconfig statement that configures
  44  *      the TUN or TAP device such as:
  45  *
  46  *      ifconfig $1 10.1.0.2 pointopoint 10.1.0.1 mtu 1450
  47  *
  48  *    Compression overflow bytes is the worst-case size expansion that would be
  49  *    expected if we tried to compress mtu + extra_frame bytes of uncompressible data.
  50  */
  51
  52 /*
  53  * Standard ethernet MTU
  54  */
  55 #define ETHERNET_MTU       1500
  56
  57 /*
  58  * It is a fatal error if mtu is less than
  59  * this value for tun device.
  60  */
  61 #define TUN_MTU_MIN        100
  62
  63 /*
  64  * Default MTU of network over which tunnel data will pass by TCP/UDP.
  65  */
  66 #define LINK_MTU_DEFAULT   1500
  67
  68 /*
  69  * Default MTU of tunnel device.
  70  */
  71 #define TUN_MTU_DEFAULT    1500
  72
  73 /*
  74  * MTU Defaults for TAP devices
  75  */
  76 #define TAP_MTU_EXTRA_DEFAULT  32
  77
  78 /*
  79  * Default MSSFIX value, used for reducing TCP MTU size
  80  */
  81 #define MSSFIX_DEFAULT     1450
  82
  83 /*
  84  * Alignment of payload data such as IP packet or
  85  * ethernet frame.
  86  */
  87 #define PAYLOAD_ALIGN 4
  88
  89 struct frame {
  90   /*
  91    * Maximum datagram size to be sent over the tunnel TCP/UDP channel.
  92    */
  93   int link_mtu;
  94   int link_mtu_dynamic;
  95
  96   /*
  97    * How many extra bytes might each subsystem (crypto, TLS, or, compression)
  98    * add to frame in worst case?
  99    *
 100    * mtu + extra_frame = MTU of TCP/UDP transport
 101    */
 102   int extra_frame;
 103
 104   /*
 105    * Worst case size added to internal buffer due to functions
 106    * such as compression which can potentially expand the size of uncompressible
 107    * data.
 108    */
 109   int extra_buffer;
 110
 111   /*
 112    * Max number of bytes in excess of tun mtu size that we might read
 113    * or write from TUN/TAP device.
 114    */
 115   int extra_tun;
 116
 117   /*
 118    * Max number of bytes in excess of link mtu size that we might read
 119    * or write from UDP/TCP link.
 120    */
 121   int extra_link;
 122
 123   /*
 124    * Alignment control
 125    */
 126 # define FRAME_HEADROOM_MARKER_DECRYPT     (1<<0)
 127 # define FRAME_HEADROOM_MARKER_FRAGMENT    (1<<1)
 128 # define FRAME_HEADROOM_MARKER_READ_LINK   (1<<2)
 129 # define FRAME_HEADROOM_MARKER_READ_STREAM (1<<3)
 130   unsigned int align_flags;
 131   int align_adjust;
 132 };
 133
 134 /* Routines which read struct frame should use the macros below */
 135
 136 /*
 137  * Overhead added to packet payload due to encapsulation
 138  */
 139 #define EXTRA_FRAME(f)           ((f)->extra_frame)
 140
 141 /*
 142  * Delta between tun payload size and final TCP/UDP datagram size
 143  * (not including extra_link additions)
 144  */
 145 #define TUN_LINK_DELTA(f)        ((f)->extra_frame + (f)->extra_tun)
 146
 147 /*
 148  * This is the size to "ifconfig" the tun or tap device.
 149  */
 150 #define TUN_MTU_SIZE(f)          ((f)->link_mtu - TUN_LINK_DELTA(f))
 151 #define TUN_MTU_SIZE_DYNAMIC(f)  ((f)->link_mtu_dynamic - TUN_LINK_DELTA(f))
 152
 153 /*
 154  * This is the maximum packet size that we need to be able to
 155  * read from or write to a tun or tap device.  For example,
 156  * a tap device ifconfiged to an MTU of 1200 might actually want
 157  * to return a packet size of 1214 on a read().
 158  */
 159 #define PAYLOAD_SIZE(f)          ((f)->link_mtu - (f)->extra_frame)
 160 #define PAYLOAD_SIZE_DYNAMIC(f)  ((f)->link_mtu_dynamic - (f)->extra_frame)
 161
 162 /*
 163  * Max size of a payload packet after encryption, compression, etc.
 164  * overhead is added.
 165  */
 166 #define EXPANDED_SIZE(f)         ((f)->link_mtu)
 167 #define EXPANDED_SIZE_DYNAMIC(f) ((f)->link_mtu_dynamic)
 168 #define EXPANDED_SIZE_MIN(f)     (TUN_MTU_MIN + TUN_LINK_DELTA(f))
 169
 170 /*
 171  * These values are used as maximum size constraints
 172  * on read() or write() from TUN/TAP device or TCP/UDP port.
 173  */
 174 #define MAX_RW_SIZE_TUN(f)       (PAYLOAD_SIZE(f))
 175 #define MAX_RW_SIZE_LINK(f)      (EXPANDED_SIZE(f) + (f)->extra_link)
 176
 177 /*
 178  * Control buffer headroom allocations to allow for efficient prepending.
 179  */
 180 #define FRAME_HEADROOM_BASE(f)     (TUN_LINK_DELTA(f) + (f)->extra_buffer + (f)->extra_link)
 181 #define FRAME_HEADROOM(f)          frame_headroom(f, 0)
 182 #define FRAME_HEADROOM_ADJ(f, fm)  frame_headroom(f, fm)
 183
 184 /*
 185  * Max size of a buffer used to build a packet for output to
 186  * the TCP/UDP port.
 187  */
 188 #define BUF_SIZE(f)              (TUN_MTU_SIZE(f) + FRAME_HEADROOM_BASE(f) * 2)
 189
 190 /*
 191  * Function prototypes.
 192  */
 193
 194 void frame_finalize (struct frame *frame,
 195                      bool link_mtu_defined,
 196                      int link_mtu,
 197                      bool tun_mtu_defined,
 198                      int tun_mtu);
 199
 200 void frame_subtract_extra (struct frame *frame, const struct frame *src);
 201
 202 void frame_print (const struct frame *frame,
 203                   int level,
 204                   const char *prefix);
 205
 206 void set_mtu_discover_type (int sd, int mtu_type);
 207 int translate_mtu_discover_type_name (const char *name);
 208
 209 /*
 210  * frame_set_mtu_dynamic and flags
 211  */
 212
 213 #define SET_MTU_TUN         (1<<0) /* use tun/tap rather than link sizing */
 214 #define SET_MTU_UPPER_BOUND (1<<1) /* only decrease dynamic MTU */
 215
 216 void frame_set_mtu_dynamic (struct frame *frame, int mtu, unsigned int flags);
 217
 218 /*
 219  * allocate a buffer for socket or tun layer
 220  */
 221 void alloc_buf_sock_tun (struct buffer *buf,
 222                          const struct frame *frame,
 223                          const bool tuntap_buffer,
 224                          const unsigned int align_mask);
 225
 226 /*
 227  * EXTENDED_SOCKET_ERROR_CAPABILITY functions -- print extra error info
 228  * on socket errors, such as PMTU size.  As of 2003.05.11, only works
 229  * on Linux 2.4+.
 230  */
 231
 232 #if EXTENDED_SOCKET_ERROR_CAPABILITY
 233
 234 void set_sock_extended_error_passing (int sd);
 235 const char *format_extended_socket_error (int fd, int *mtu, struct gc_arena *gc);
 236
 237 #endif
 238
 239 /*
 240  * Calculate a starting offset into a buffer object, dealing with
 241  * headroom and alignment issues.
 242  */
 243 static inline int
 244 frame_headroom (const struct frame *f, const unsigned int flag_mask)
 245 {
 246   const int offset = FRAME_HEADROOM_BASE (f);
 247   const int adjust = (flag_mask & f->align_flags) ? f->align_adjust : 0;
 248   const int delta = ((PAYLOAD_ALIGN << 24) - (offset + adjust)) & (PAYLOAD_ALIGN - 1);
 249   return offset + delta;
 250 }
 251
 252 /*
 253  * frame member adjustment functions
 254  */
 255
 256 static inline void
 257 frame_add_to_extra_frame (struct frame *frame, const int increment)
 258 {
 259   frame->extra_frame += increment;
 260 }
 261
 262 static inline void
 263 frame_add_to_extra_tun (struct frame *frame, const int increment)
 264 {
 265   frame->extra_tun += increment;
 266 }
 267
 268 static inline void
 269 frame_add_to_extra_link (struct frame *frame, const int increment)
 270 {
 271   frame->extra_link += increment;
 272 }
 273
 274 static inline void
 275 frame_add_to_extra_buffer (struct frame *frame, const int increment)
 276 {
 277   frame->extra_buffer += increment;
 278 }
 279
 280 static inline void
 281 frame_add_to_align_adjust (struct frame *frame, const int increment)
 282 {
 283   frame->align_adjust += increment;
 284 }
 285
 286 static inline void
 287 frame_align_to_extra_frame (struct frame *frame)
 288 {
 289   frame->align_adjust = frame->extra_frame + frame->extra_link;
 290 }
 291
 292 static inline void
 293 frame_or_align_flags (struct frame *frame, const unsigned int flag_mask)
 294 {
 295   frame->align_flags |= flag_mask;
 296 }
 297
 298 static inline bool
 299 frame_defined (const struct frame *frame)
 300 {
 301   return frame->link_mtu > 0;
 302 }
 303
 304 #endif