src/plugins/mss_clamp/mss_clamp_node.c

   1 /*
   2  * mss_clamp_node.c - Node implementing TCP MSS clamping
   3  *
   4  * Copyright (c) 2018 Cisco and/or its affiliates
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 #include <vlib/vlib.h>
  18 #include <vnet/vnet.h>
  19 #include <vnet/pg/pg.h>
  20 #include <vppinfra/error.h>
  21 #include <mss_clamp/mss_clamp.h>
  22 #include <mss_clamp/mss_clamp.api_enum.h>
  23 #include <vnet/fib/fib_types.h>
  24 #include <vnet/feature/feature.h>
  25 #include <vnet/ip/ip4.h>
  26 #include <vnet/ip/ip6.h>
  27
  28 extern vlib_node_registration_t mssc_ip4_in_node, mssc_ip4_out_node;
  29 extern vlib_node_registration_t mssc_ip6_in_node, mssc_ip6_out_node;
  30
  31 typedef struct mssc_trace_t_
  32 {
  33   u32 max_mss;
  34   u32 clamped;
  35 } mssc_trace_t;
  36
  37 /* packet trace format function */
  38 static u8 *
  39 format_mssc_trace (u8 *s, va_list *args)
  40 {
  41   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  42   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  43   mssc_trace_t *t = va_arg (*args, mssc_trace_t *);
  44
  45   s = format (s, "max mss: %d clamped: %d", t->max_mss, t->clamped);
  46   return s;
  47 }
  48
  49 typedef enum
  50 {
  51   MSSC_NEXT_DROP,
  52   MSSC_N_NEXT,
  53 } mssc_next_t;
  54
  55 /*
  56  * fixup the maximum segment size if it's a syn packet
  57  * return 1 if the mss was changed otherwise 0
  58  */
  59 always_inline u32
  60 mssc_mss_fixup (vlib_buffer_t *b0, tcp_header_t *tcp0, u16 max_mss0)
  61 {
  62   ip_csum_t sum0;
  63
  64   if (PREDICT_FALSE (tcp_syn (tcp0)))
  65     {
  66       u8 opt_len, opts_len, kind;
  67       const u8 *data;
  68       u16 mss0, new_mss0;
  69
  70       opts_len = (tcp_doff (tcp0) << 2) - sizeof (tcp_header_t);
  71       data = (const u8 *) (tcp0 + 1);
  72
  73       for (; opts_len > 0; opts_len -= opt_len, data += opt_len)
  74         {
  75           kind = data[0];
  76
  77           /* Get options length */
  78           if (kind == TCP_OPTION_EOL)
  79             break;
  80           else if (kind == TCP_OPTION_NOOP)
  81             {
  82               opt_len = 1;
  83               continue;
  84             }
  85           else
  86             {
  87               /* broken options */
  88               if (opts_len < 2)
  89                 return 0;
  90               opt_len = data[1];
  91
  92               /* weird option length */
  93               if (opt_len < 2 || opt_len > opts_len)
  94                 return 0;
  95             }
  96
  97           if (kind == TCP_OPTION_MSS)
  98             {
  99               mss0 = *(u16 *) (data + 2);
 100               if (clib_net_to_host_u16 (mss0) > max_mss0)
 101                 {
 102                   new_mss0 = clib_host_to_net_u16 (max_mss0);
 103                   *((u16 *) (data + 2)) = new_mss0;
 104                   sum0 = tcp0->checksum;
 105                   sum0 = ip_csum_update (sum0, mss0, new_mss0, tcp_header_t,
 106                                          checksum);
 107                   tcp0->checksum = ip_csum_fold (sum0);
 108                   return 1;
 109                 }
 110             }
 111         }
 112     }
 113
 114   return 0;
 115 }
 116
 117 always_inline uword
 118 mssc_inline (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame,
 119              vlib_dir_t dir, fib_protocol_t fproto)
 120 {
 121   mssc_main_t *cm = &mssc_main;
 122   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
 123   u16 nexts[VLIB_FRAME_SIZE], *next;
 124   u32 n_left, *from;
 125   u32 pkts_clamped = 0;
 126
 127   from = vlib_frame_vector_args (frame);
 128   n_left = frame->n_vectors;
 129   b = bufs;
 130   next = nexts;
 131
 132   vlib_get_buffers (vm, from, bufs, n_left);
 133
 134   while (n_left >= 4)
 135     {
 136       u32 sw_if_index0, sw_if_index1;
 137       const u8 *h0, *h1;
 138       u32 clamped0, clamped1;
 139
 140       /* Prefetch next iteration. */
 141       {
 142         vlib_prefetch_buffer_header (b[2], LOAD);
 143         vlib_prefetch_buffer_header (b[3], LOAD);
 144         vlib_prefetch_buffer_data (b[2], LOAD);
 145         vlib_prefetch_buffer_data (b[3], LOAD);
 146       }
 147
 148       sw_if_index0 = vnet_buffer (b[0])->sw_if_index[dir];
 149       sw_if_index1 = vnet_buffer (b[1])->sw_if_index[dir];
 150       clamped0 = clamped1 = 0;
 151
 152       /* speculatively enqueue b0 to the current next frame */
 153       vnet_feature_next_u16 (&next[0], b[0]);
 154       vnet_feature_next_u16 (&next[1], b[1]);
 155
 156       h0 = (u8 *) vlib_buffer_get_current (b[0]);
 157       h1 = (u8 *) vlib_buffer_get_current (b[1]);
 158       if (VLIB_TX == dir)
 159         {
 160           h0 += vnet_buffer (b[0])->ip.save_rewrite_length;
 161           h1 += vnet_buffer (b[1])->ip.save_rewrite_length;
 162         }
 163
 164       if (FIB_PROTOCOL_IP4 == fproto)
 165         {
 166           ip4_header_t *ip0 = (ip4_header_t *) h0;
 167           ip4_header_t *ip1 = (ip4_header_t *) h1;
 168
 169           if (IP_PROTOCOL_TCP == ip0->protocol)
 170             {
 171               clamped0 = mssc_mss_fixup (b[0], ip4_next_header (ip0),
 172                                          cm->max_mss4[sw_if_index0]);
 173             }
 174           if (IP_PROTOCOL_TCP == ip1->protocol)
 175             {
 176               clamped1 = mssc_mss_fixup (b[1], ip4_next_header (ip1),
 177                                          cm->max_mss4[sw_if_index1]);
 178             }
 179         }
 180       else if (FIB_PROTOCOL_IP6 == fproto)
 181         {
 182           ip6_header_t *ip0 = (ip6_header_t *) h0;
 183           ip6_header_t *ip1 = (ip6_header_t *) h1;
 184
 185           if (IP_PROTOCOL_TCP == ip0->protocol)
 186             {
 187               clamped0 = mssc_mss_fixup (b[0], ip6_next_header (ip0),
 188                                          cm->max_mss6[sw_if_index0]);
 189             }
 190           if (IP_PROTOCOL_TCP == ip1->protocol)
 191             {
 192               clamped1 = mssc_mss_fixup (b[1], ip6_next_header (ip1),
 193                                          cm->max_mss6[sw_if_index1]);
 194             }
 195         }
 196
 197       pkts_clamped += clamped0 + clamped1;
 198
 199       if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE))
 200         {
 201           if (b[0]->flags & VLIB_BUFFER_IS_TRACED)
 202             {
 203               mssc_trace_t *t;
 204
 205               t = vlib_add_trace (vm, node, b[0], sizeof (*t));
 206               t->max_mss = (FIB_PROTOCOL_IP4 == fproto) ?
 207                              cm->max_mss4[sw_if_index0] :
 208                              cm->max_mss6[sw_if_index0];
 209               t->clamped = clamped0;
 210             }
 211           if (b[1]->flags & VLIB_BUFFER_IS_TRACED)
 212             {
 213               mssc_trace_t *t;
 214
 215               t = vlib_add_trace (vm, node, b[1], sizeof (*t));
 216               t->max_mss = (FIB_PROTOCOL_IP4 == fproto) ?
 217                              cm->max_mss4[sw_if_index1] :
 218                              cm->max_mss6[sw_if_index1];
 219               t->clamped = clamped1;
 220             }
 221         }
 222
 223       b += 2;
 224       next += 2;
 225       n_left -= 2;
 226     }
 227
 228   while (n_left > 0)
 229     {
 230       u32 sw_if_index0;
 231       const u8 *h0;
 232       u32 clamped0;
 233
 234       sw_if_index0 = vnet_buffer (b[0])->sw_if_index[dir];
 235       clamped0 = 0;
 236
 237       /* speculatively enqueue b0 to the current next frame */
 238       vnet_feature_next_u16 (&next[0], b[0]);
 239
 240       h0 = (u8 *) vlib_buffer_get_current (b[0]);
 241       if (VLIB_TX == dir)
 242         h0 += vnet_buffer (b[0])->ip.save_rewrite_length;
 243
 244       if (FIB_PROTOCOL_IP4 == fproto)
 245         {
 246           ip4_header_t *ip0 = (ip4_header_t *) h0;
 247
 248           if (IP_PROTOCOL_TCP == ip0->protocol)
 249             {
 250               clamped0 = mssc_mss_fixup (b[0], ip4_next_header (ip0),
 251                                          cm->max_mss4[sw_if_index0]);
 252             }
 253         }
 254       else if (FIB_PROTOCOL_IP6 == fproto)
 255         {
 256           ip6_header_t *ip0 = (ip6_header_t *) h0;
 257
 258           if (IP_PROTOCOL_TCP == ip0->protocol)
 259             {
 260               clamped0 = mssc_mss_fixup (b[0], ip6_next_header (ip0),
 261                                          cm->max_mss6[sw_if_index0]);
 262             }
 263         }
 264
 265       pkts_clamped += clamped0;
 266
 267       if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
 268                          (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
 269         {
 270           mssc_trace_t *t;
 271
 272           t = vlib_add_trace (vm, node, b[0], sizeof (*t));
 273           t->max_mss = (FIB_PROTOCOL_IP4 == fproto) ?
 274                          cm->max_mss4[sw_if_index0] :
 275                          cm->max_mss6[sw_if_index0];
 276           t->clamped = clamped0;
 277         }
 278
 279       b++;
 280       next++;
 281       n_left--;
 282     }
 283
 284   vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
 285   vlib_node_increment_counter (vm, node->node_index, MSS_CLAMP_ERROR_CLAMPED,
 286                                pkts_clamped);
 287
 288   return frame->n_vectors;
 289 }
 290
 291 static uword
 292 mssc_ip4_in (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
 293 {
 294   return (mssc_inline (vm, node, frame, VLIB_RX, FIB_PROTOCOL_IP4));
 295 }
 296
 297 static uword
 298 mssc_ip4_out (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
 299 {
 300   return (mssc_inline (vm, node, frame, VLIB_TX, FIB_PROTOCOL_IP4));
 301 }
 302
 303 static uword
 304 mssc_ip6_in (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
 305 {
 306   return (mssc_inline (vm, node, frame, VLIB_RX, FIB_PROTOCOL_IP6));
 307 }
 308
 309 static uword
 310 mssc_ip6_out (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
 311 {
 312   return (mssc_inline (vm, node, frame, VLIB_TX, FIB_PROTOCOL_IP6));
 313 }
 314
 315 VLIB_REGISTER_NODE (mssc_ip4_in_node) =
 316 {
 317   .function = mssc_ip4_in,
 318   .name = "tcp-mss-clamping-ip4-in",
 319   .vector_size = sizeof (u32),
 320   .format_trace = format_mssc_trace,
 321   .type = VLIB_NODE_TYPE_INTERNAL,
 322
 323   .n_errors = MSS_CLAMP_N_ERROR,
 324   .error_counters = mss_clamp_error_counters,
 325
 326   .n_next_nodes = MSSC_N_NEXT,
 327   .next_nodes = {
 328         [MSSC_NEXT_DROP] = "error-drop",
 329   },
 330 };
 331
 332 VLIB_REGISTER_NODE (mssc_ip4_out_node) =
 333 {
 334   .function = mssc_ip4_out,
 335   .name = "tcp-mss-clamping-ip4-out",
 336   .vector_size = sizeof (u32),
 337   .format_trace = format_mssc_trace,
 338   .type = VLIB_NODE_TYPE_INTERNAL,
 339
 340   .n_errors = MSS_CLAMP_N_ERROR,
 341   .error_counters = mss_clamp_error_counters,
 342
 343   .n_next_nodes = MSSC_N_NEXT,
 344   .next_nodes = {
 345         [MSSC_NEXT_DROP] = "error-drop",
 346   },
 347 };
 348
 349 VLIB_REGISTER_NODE (mssc_ip6_in_node) =
 350 {
 351   .function = mssc_ip6_in,
 352   .name = "tcp-mss-clamping-ip6-in",
 353   .vector_size = sizeof (u32),
 354   .format_trace = format_mssc_trace,
 355   .type = VLIB_NODE_TYPE_INTERNAL,
 356
 357   .n_errors = MSS_CLAMP_N_ERROR,
 358   .error_counters = mss_clamp_error_counters,
 359
 360   .n_next_nodes = MSSC_N_NEXT,
 361   .next_nodes = {
 362         [MSSC_NEXT_DROP] = "error-drop",
 363   },
 364 };
 365
 366 VLIB_REGISTER_NODE (mssc_ip6_out_node) =
 367 {
 368   .function = mssc_ip6_out,
 369   .name = "tcp-mss-clamping-ip6-out",
 370   .vector_size = sizeof (u32),
 371   .format_trace = format_mssc_trace,
 372   .type = VLIB_NODE_TYPE_INTERNAL,
 373
 374   .n_errors = MSS_CLAMP_N_ERROR,
 375   .error_counters = mss_clamp_error_counters,
 376
 377   .n_next_nodes = MSSC_N_NEXT,
 378   .next_nodes = {
 379         [MSSC_NEXT_DROP] = "error-drop",
 380   },
 381 };
 382
 383 VNET_FEATURE_INIT (mssc_ip4_in_feat, static) = {
 384   .arc_name = "ip4-unicast",
 385   .node_name = "tcp-mss-clamping-ip4-in",
 386   .runs_after = VNET_FEATURES ("ip4-policer-classify"),
 387 };
 388
 389 VNET_FEATURE_INIT (mssc_ip4_out_feat, static) = {
 390   .arc_name = "ip4-output",
 391   .node_name = "tcp-mss-clamping-ip4-out",
 392 };
 393
 394 VNET_FEATURE_INIT (mssc_ip6_in_feat, static) = {
 395   .arc_name = "ip6-unicast",
 396   .node_name = "tcp-mss-clamping-ip6-in",
 397   .runs_after = VNET_FEATURES ("ip6-policer-classify"),
 398 };
 399
 400 VNET_FEATURE_INIT (mssc_ip6_out_feat, static) = {
 401   .arc_name = "ip6-output",
 402   .node_name = "tcp-mss-clamping-ip6-out",
 403 };
 404
 405 /*
 406  * fd.io coding-style-patch-verification: ON
 407  *
 408  * Local Variables:
 409  * eval: (c-set-style "gnu")
 410  * End:
 411  */