src/vnet/udp/udp_local.c

   1 /*
   2  * node.c: udp packet processing
   3  *
   4  * Copyright (c) 2013-2019 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
  18 #include <vlib/vlib.h>
  19 #include <vnet/pg/pg.h>
  20 #include <vnet/udp/udp.h>
  21 #include <vnet/udp/udp_packet.h>
  22 #include <vppinfra/sparse_vec.h>
  23
  24 typedef enum
  25 {
  26   UDP_LOCAL_NEXT_PUNT,
  27   UDP_LOCAL_NEXT_DROP,
  28   UDP_LOCAL_NEXT_ICMP,
  29   UDP_LOCAL_N_NEXT
  30 } udp_local_next_t;
  31
  32 typedef struct
  33 {
  34   u16 src_port;
  35   u16 dst_port;
  36   u8 bound;
  37 } udp_local_rx_trace_t;
  38
  39 static vlib_error_desc_t udp_error_counters[] = {
  40 #define udp_error(f, n, s, d) { #n, d, VL_COUNTER_SEVERITY_##s },
  41 #include "udp_error.def"
  42 #undef udp_error
  43 };
  44
  45 #ifndef CLIB_MARCH_VARIANT
  46 u8 *
  47 format_udp_rx_trace (u8 * s, va_list * args)
  48 {
  49   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  50   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  51   udp_local_rx_trace_t *t = va_arg (*args, udp_local_rx_trace_t *);
  52
  53   s = format (s, "UDP: src-port %d dst-port %d%s",
  54               clib_net_to_host_u16 (t->src_port),
  55               clib_net_to_host_u16 (t->dst_port),
  56               t->bound ? "" : " (no listener)");
  57   return s;
  58 }
  59 #endif /* CLIB_MARCH_VARIANT */
  60
  61 always_inline void
  62 udp_dispatch_error (vlib_node_runtime_t *node, vlib_buffer_t *b, u32 advance,
  63                     u8 is_ip4, u32 *next)
  64 {
  65   udp_main_t *um = &udp_main;
  66   u8 punt_unknown = is_ip4 ? um->punt_unknown4 : um->punt_unknown6;
  67
  68   if (PREDICT_FALSE (punt_unknown))
  69     {
  70       vlib_buffer_advance (b, -(word) advance);
  71       b->error = node->errors[UDP_ERROR_PUNT];
  72       *next = UDP_LOCAL_NEXT_PUNT;
  73     }
  74   else if (um->icmp_send_unreachable_disabled)
  75     {
  76       *next = UDP_LOCAL_NEXT_DROP;
  77       b->error = node->errors[UDP_ERROR_NO_LISTENER];
  78     }
  79   else
  80     {
  81       /* move the pointer back so icmp-error can find the ip packet header */
  82       vlib_buffer_advance (b, -(word) advance);
  83
  84       if (is_ip4)
  85         {
  86           icmp4_error_set_vnet_buffer (
  87             b, ICMP4_destination_unreachable,
  88             ICMP4_destination_unreachable_port_unreachable, 0);
  89           b->error = node->errors[UDP_ERROR_NO_LISTENER];
  90           *next = UDP_LOCAL_NEXT_ICMP;
  91         }
  92       else
  93         {
  94           icmp6_error_set_vnet_buffer (
  95             b, ICMP6_destination_unreachable,
  96             ICMP6_destination_unreachable_port_unreachable, 0);
  97           b->error = node->errors[UDP_ERROR_NO_LISTENER];
  98           *next = UDP_LOCAL_NEXT_ICMP;
  99         }
 100     }
 101 }
 102
 103 always_inline uword
 104 udp46_local_inline (vlib_main_t * vm,
 105                     vlib_node_runtime_t * node,
 106                     vlib_frame_t * from_frame, int is_ip4)
 107 {
 108   udp_main_t *um = &udp_main;
 109   __attribute__ ((unused)) u32 n_left_from, next_index, *from, *to_next;
 110   u16 *next_by_dst_port = (is_ip4 ?
 111                            um->next_by_dst_port4 : um->next_by_dst_port6);
 112   from = vlib_frame_vector_args (from_frame);
 113   n_left_from = from_frame->n_vectors;
 114
 115   next_index = node->cached_next_index;
 116
 117   while (n_left_from > 0)
 118     {
 119       u32 n_left_to_next;
 120
 121       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 122
 123       while (n_left_from >= 4 && n_left_to_next >= 2)
 124         {
 125           u32 bi0, bi1;
 126           vlib_buffer_t *b0, *b1;
 127           udp_header_t *h0 = 0, *h1 = 0;
 128           u32 i0, i1, dst_port0, dst_port1;
 129           u32 advance0, advance1;
 130           u32 error0, next0, error1, next1;
 131
 132           /* Prefetch next iteration. */
 133           {
 134             vlib_buffer_t *p2, *p3;
 135
 136             p2 = vlib_get_buffer (vm, from[2]);
 137             p3 = vlib_get_buffer (vm, from[3]);
 138
 139             vlib_prefetch_buffer_header (p2, LOAD);
 140             vlib_prefetch_buffer_header (p3, LOAD);
 141
 142             CLIB_PREFETCH (p2->data, sizeof (h0[0]), LOAD);
 143             CLIB_PREFETCH (p3->data, sizeof (h1[0]), LOAD);
 144           }
 145
 146           bi0 = from[0];
 147           bi1 = from[1];
 148           to_next[0] = bi0;
 149           to_next[1] = bi1;
 150           from += 2;
 151           to_next += 2;
 152           n_left_to_next -= 2;
 153           n_left_from -= 2;
 154
 155           b0 = vlib_get_buffer (vm, bi0);
 156           b1 = vlib_get_buffer (vm, bi1);
 157
 158           /* ip4/6_local hands us the ip header, not the udp header */
 159           if (is_ip4)
 160             {
 161               advance0 = ip4_header_bytes (vlib_buffer_get_current (b0));
 162               advance1 = ip4_header_bytes (vlib_buffer_get_current (b1));
 163             }
 164           else
 165             {
 166               advance0 = sizeof (ip6_header_t);
 167               advance1 = sizeof (ip6_header_t);
 168             }
 169
 170           if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
 171             {
 172               error0 = UDP_ERROR_LENGTH_ERROR;
 173               next0 = UDP_LOCAL_NEXT_DROP;
 174             }
 175           else
 176             {
 177               vlib_buffer_advance (b0, advance0);
 178               h0 = vlib_buffer_get_current (b0);
 179               error0 = UDP_ERROR_NONE;
 180               next0 = UDP_LOCAL_NEXT_PUNT;
 181               if (PREDICT_FALSE (clib_net_to_host_u16 (h0->length) >
 182                                  vlib_buffer_length_in_chain (vm, b0)))
 183                 {
 184                   error0 = UDP_ERROR_LENGTH_ERROR;
 185                   next0 = UDP_LOCAL_NEXT_DROP;
 186                 }
 187             }
 188
 189           if (PREDICT_FALSE (b1->current_length < advance1 + sizeof (*h1)))
 190             {
 191               error1 = UDP_ERROR_LENGTH_ERROR;
 192               next1 = UDP_LOCAL_NEXT_DROP;
 193             }
 194           else
 195             {
 196               vlib_buffer_advance (b1, advance1);
 197               h1 = vlib_buffer_get_current (b1);
 198               error1 = UDP_ERROR_NONE;
 199               next1 = UDP_LOCAL_NEXT_PUNT;
 200               if (PREDICT_FALSE (clib_net_to_host_u16 (h1->length) >
 201                                  vlib_buffer_length_in_chain (vm, b1)))
 202                 {
 203                   error1 = UDP_ERROR_LENGTH_ERROR;
 204                   next1 = UDP_LOCAL_NEXT_DROP;
 205                 }
 206             }
 207
 208           /* Index sparse array with network byte order. */
 209           dst_port0 = (error0 == 0) ? h0->dst_port : 0;
 210           dst_port1 = (error1 == 0) ? h1->dst_port : 0;
 211           sparse_vec_index2 (next_by_dst_port, dst_port0, dst_port1, &i0,
 212                              &i1);
 213           next0 = (error0 == 0) ? vec_elt (next_by_dst_port, i0) : next0;
 214           next1 = (error1 == 0) ? vec_elt (next_by_dst_port, i1) : next1;
 215
 216           if (PREDICT_FALSE (i0 == SPARSE_VEC_INVALID_INDEX ||
 217                              next0 == UDP_NO_NODE_SET))
 218             {
 219               udp_dispatch_error (node, b0, advance0, is_ip4, &next0);
 220             }
 221           else
 222             {
 223               b0->error = node->errors[UDP_ERROR_NONE];
 224               // advance to the payload
 225               vlib_buffer_advance (b0, sizeof (*h0));
 226             }
 227
 228           if (PREDICT_FALSE (i1 == SPARSE_VEC_INVALID_INDEX ||
 229                              next1 == UDP_NO_NODE_SET))
 230             {
 231               udp_dispatch_error (node, b1, advance1, is_ip4, &next1);
 232             }
 233           else
 234             {
 235               b1->error = node->errors[UDP_ERROR_NONE];
 236               // advance to the payload
 237               vlib_buffer_advance (b1, sizeof (*h1));
 238             }
 239
 240           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 241             {
 242               udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
 243                                                          b0, sizeof (*tr));
 244               if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
 245                 {
 246                   tr->src_port = h0 ? h0->src_port : 0;
 247                   tr->dst_port = h0 ? h0->dst_port : 0;
 248                   tr->bound = (next0 != UDP_LOCAL_NEXT_ICMP);
 249                 }
 250             }
 251           if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
 252             {
 253               udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
 254                                                          b1, sizeof (*tr));
 255               if (b1->error != node->errors[UDP_ERROR_LENGTH_ERROR])
 256                 {
 257                   tr->src_port = h1 ? h1->src_port : 0;
 258                   tr->dst_port = h1 ? h1->dst_port : 0;
 259                   tr->bound = (next1 != UDP_LOCAL_NEXT_ICMP);
 260                 }
 261             }
 262
 263           vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
 264                                            to_next, n_left_to_next,
 265                                            bi0, bi1, next0, next1);
 266         }
 267
 268       while (n_left_from > 0 && n_left_to_next > 0)
 269         {
 270           u32 bi0;
 271           vlib_buffer_t *b0;
 272           udp_header_t *h0 = 0;
 273           u32 i0, next0;
 274           u32 advance0;
 275
 276           bi0 = from[0];
 277           to_next[0] = bi0;
 278           from += 1;
 279           to_next += 1;
 280           n_left_from -= 1;
 281           n_left_to_next -= 1;
 282
 283           b0 = vlib_get_buffer (vm, bi0);
 284
 285           /* ip4/6_local hands us the ip header, not the udp header */
 286           if (is_ip4)
 287             advance0 = ip4_header_bytes (vlib_buffer_get_current (b0));
 288           else
 289             advance0 = sizeof (ip6_header_t);
 290
 291           if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
 292             {
 293               b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
 294               next0 = UDP_LOCAL_NEXT_DROP;
 295               goto trace_x1;
 296             }
 297
 298           vlib_buffer_advance (b0, advance0);
 299
 300           h0 = vlib_buffer_get_current (b0);
 301
 302           if (PREDICT_TRUE (clib_net_to_host_u16 (h0->length) <=
 303                             vlib_buffer_length_in_chain (vm, b0)))
 304             {
 305               i0 = sparse_vec_index (next_by_dst_port, h0->dst_port);
 306               next0 = vec_elt (next_by_dst_port, i0);
 307
 308               if (PREDICT_FALSE ((i0 == SPARSE_VEC_INVALID_INDEX) ||
 309                                  next0 == UDP_NO_NODE_SET))
 310                 {
 311                   udp_dispatch_error (node, b0, advance0, is_ip4, &next0);
 312                 }
 313               else
 314                 {
 315                   b0->error = node->errors[UDP_ERROR_NONE];
 316                   // advance to the payload
 317                   vlib_buffer_advance (b0, sizeof (*h0));
 318                 }
 319             }
 320           else
 321             {
 322               b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
 323               next0 = UDP_LOCAL_NEXT_DROP;
 324             }
 325
 326         trace_x1:
 327           if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
 328             {
 329               udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
 330                                                          b0, sizeof (*tr));
 331               if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
 332                 {
 333                   tr->src_port = h0->src_port;
 334                   tr->dst_port = h0->dst_port;
 335                   tr->bound = (next0 != UDP_LOCAL_NEXT_ICMP);
 336                 }
 337             }
 338
 339           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 340                                            to_next, n_left_to_next,
 341                                            bi0, next0);
 342         }
 343
 344       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 345     }
 346   return from_frame->n_vectors;
 347 }
 348
 349 VLIB_NODE_FN (udp4_local_node) (vlib_main_t * vm,
 350                                 vlib_node_runtime_t * node,
 351                                 vlib_frame_t * from_frame)
 352 {
 353   return udp46_local_inline (vm, node, from_frame, 1 /* is_ip4 */ );
 354 }
 355
 356 VLIB_NODE_FN (udp6_local_node) (vlib_main_t * vm,
 357                                 vlib_node_runtime_t * node,
 358                                 vlib_frame_t * from_frame)
 359 {
 360   return udp46_local_inline (vm, node, from_frame, 0 /* is_ip4 */ );
 361 }
 362
 363 /* *INDENT-OFF* */
 364 VLIB_REGISTER_NODE (udp4_local_node) = {
 365   .name = "ip4-udp-lookup",
 366   /* Takes a vector of packets. */
 367   .vector_size = sizeof (u32),
 368
 369   .n_errors = UDP_N_ERROR,
 370   .error_counters = udp_error_counters,
 371
 372   .n_next_nodes = UDP_LOCAL_N_NEXT,
 373   .next_nodes = {
 374     [UDP_LOCAL_NEXT_PUNT]= "ip4-punt",
 375     [UDP_LOCAL_NEXT_DROP]= "ip4-drop",
 376     [UDP_LOCAL_NEXT_ICMP]= "ip4-icmp-error",
 377   },
 378
 379   .format_buffer = format_udp_header,
 380   .format_trace = format_udp_rx_trace,
 381   .unformat_buffer = unformat_udp_header,
 382 };
 383 /* *INDENT-ON* */
 384
 385 /* *INDENT-OFF* */
 386 VLIB_REGISTER_NODE (udp6_local_node) = {
 387   .name = "ip6-udp-lookup",
 388   /* Takes a vector of packets. */
 389   .vector_size = sizeof (u32),
 390
 391   .n_errors = UDP_N_ERROR,
 392   .error_counters = udp_error_counters,
 393
 394   .n_next_nodes = UDP_LOCAL_N_NEXT,
 395   .next_nodes = {
 396     [UDP_LOCAL_NEXT_PUNT]= "ip6-punt",
 397     [UDP_LOCAL_NEXT_DROP]= "ip6-drop",
 398     [UDP_LOCAL_NEXT_ICMP]= "ip6-icmp-error",
 399   },
 400
 401   .format_buffer = format_udp_header,
 402   .format_trace = format_udp_rx_trace,
 403   .unformat_buffer = unformat_udp_header,
 404 };
 405 /* *INDENT-ON* */
 406
 407 #ifndef CLIB_MARCH_VARIANT
 408 void
 409 udp_add_dst_port (udp_main_t * um, udp_dst_port_t dst_port,
 410                   char *dst_port_name, u8 is_ip4)
 411 {
 412   udp_dst_port_info_t *pi;
 413   u32 i;
 414
 415   vec_add2 (um->dst_port_infos[is_ip4], pi, 1);
 416   i = pi - um->dst_port_infos[is_ip4];
 417
 418   pi->name = dst_port_name;
 419   pi->dst_port = dst_port;
 420   pi->next_index = pi->node_index = ~0;
 421
 422   hash_set (um->dst_port_info_by_dst_port[is_ip4], dst_port, i);
 423
 424   if (pi->name)
 425     hash_set_mem (um->dst_port_info_by_name[is_ip4], pi->name, i);
 426 }
 427
 428 void
 429 udp_register_dst_port (vlib_main_t * vm,
 430                        udp_dst_port_t dst_port, u32 node_index, u8 is_ip4)
 431 {
 432   udp_main_t *um = &udp_main;
 433   udp_dst_port_info_t *pi;
 434   u16 *n;
 435
 436   {
 437     clib_error_t *error = vlib_call_init_function (vm, udp_local_init);
 438     if (error)
 439       clib_error_report (error);
 440   }
 441
 442   pi = udp_get_dst_port_info (um, dst_port, is_ip4);
 443   if (!pi)
 444     {
 445       udp_add_dst_port (um, dst_port, 0, is_ip4);
 446       pi = udp_get_dst_port_info (um, dst_port, is_ip4);
 447       ASSERT (pi);
 448     }
 449
 450   pi->node_index = node_index;
 451   pi->next_index = vlib_node_add_next (vm,
 452                                        is_ip4 ? udp4_local_node.index
 453                                        : udp6_local_node.index, node_index);
 454
 455   /* Setup udp protocol -> next index sparse vector mapping. */
 456   if (is_ip4)
 457     n = sparse_vec_validate (um->next_by_dst_port4,
 458                              clib_host_to_net_u16 (dst_port));
 459   else
 460     n = sparse_vec_validate (um->next_by_dst_port6,
 461                              clib_host_to_net_u16 (dst_port));
 462
 463   n[0] = pi->next_index;
 464 }
 465
 466 void
 467 udp_unregister_dst_port (vlib_main_t * vm, udp_dst_port_t dst_port, u8 is_ip4)
 468 {
 469   udp_main_t *um = &udp_main;
 470   udp_dst_port_info_t *pi;
 471   u16 *n;
 472
 473   pi = udp_get_dst_port_info (um, dst_port, is_ip4);
 474   /* Not registered? Fagedaboudit */
 475   if (!pi)
 476     return;
 477
 478   /* Kill the mapping. Don't bother killing the pi, it may be back. */
 479   if (is_ip4)
 480     n = sparse_vec_validate (um->next_by_dst_port4,
 481                              clib_host_to_net_u16 (dst_port));
 482   else
 483     n = sparse_vec_validate (um->next_by_dst_port6,
 484                              clib_host_to_net_u16 (dst_port));
 485
 486   n[0] = UDP_NO_NODE_SET;
 487 }
 488
 489 u8
 490 udp_is_valid_dst_port (udp_dst_port_t dst_port, u8 is_ip4)
 491 {
 492   udp_main_t *um = &udp_main;
 493   u16 *n;
 494
 495   if (is_ip4)
 496     n = sparse_vec_validate (um->next_by_dst_port4,
 497                              clib_host_to_net_u16 (dst_port));
 498   else
 499     n = sparse_vec_validate (um->next_by_dst_port6,
 500                              clib_host_to_net_u16 (dst_port));
 501
 502   return (n[0] != SPARSE_VEC_INVALID_INDEX && n[0] != UDP_NO_NODE_SET);
 503 }
 504
 505 void
 506 udp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
 507 {
 508   udp_main_t *um = &udp_main;
 509   {
 510     clib_error_t *error = vlib_call_init_function (vm, udp_local_init);
 511     if (error)
 512       clib_error_report (error);
 513   }
 514
 515   if (is_ip4)
 516     um->punt_unknown4 = is_add;
 517   else
 518     um->punt_unknown6 = is_add;
 519 }
 520
 521 /* Parse a UDP header. */
 522 uword
 523 unformat_udp_header (unformat_input_t * input, va_list * args)
 524 {
 525   u8 **result = va_arg (*args, u8 **);
 526   udp_header_t *udp;
 527   __attribute__ ((unused)) int old_length;
 528   u16 src_port, dst_port;
 529
 530   /* Allocate space for IP header. */
 531   {
 532     void *p;
 533
 534     old_length = vec_len (*result);
 535     vec_add2 (*result, p, sizeof (ip4_header_t));
 536     udp = p;
 537   }
 538
 539   clib_memset (udp, 0, sizeof (udp[0]));
 540   if (unformat (input, "src-port %d dst-port %d", &src_port, &dst_port))
 541     {
 542       udp->src_port = clib_host_to_net_u16 (src_port);
 543       udp->dst_port = clib_host_to_net_u16 (dst_port);
 544       return 1;
 545     }
 546   return 0;
 547 }
 548
 549 static void
 550 udp_setup_node (vlib_main_t * vm, u32 node_index)
 551 {
 552   vlib_node_t *n = vlib_get_node (vm, node_index);
 553   pg_node_t *pn = pg_get_node (node_index);
 554
 555   n->format_buffer = format_udp_header;
 556   n->unformat_buffer = unformat_udp_header;
 557   pn->unformat_edit = unformat_pg_udp_header;
 558 }
 559
 560 clib_error_t *
 561 udp_local_init (vlib_main_t * vm)
 562 {
 563   udp_main_t *um = &udp_main;
 564   int i;
 565
 566   {
 567     clib_error_t *error;
 568     error = vlib_call_init_function (vm, udp_init);
 569     if (error)
 570       clib_error_report (error);
 571   }
 572
 573
 574   for (i = 0; i < 2; i++)
 575     {
 576       um->dst_port_info_by_name[i] = hash_create_string (0, sizeof (uword));
 577       um->dst_port_info_by_dst_port[i] = hash_create (0, sizeof (uword));
 578     }
 579
 580   udp_setup_node (vm, udp4_local_node.index);
 581   udp_setup_node (vm, udp6_local_node.index);
 582
 583   um->punt_unknown4 = 0;
 584   um->punt_unknown6 = 0;
 585
 586   um->next_by_dst_port4 = sparse_vec_new
 587     ( /* elt bytes */ sizeof (um->next_by_dst_port4[0]),
 588      /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
 589
 590   um->next_by_dst_port6 = sparse_vec_new
 591     ( /* elt bytes */ sizeof (um->next_by_dst_port6[0]),
 592      /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
 593
 594 #define _(n,s) udp_add_dst_port (um, UDP_DST_PORT_##s, #s, 1 /* is_ip4 */);
 595   foreach_udp4_dst_port
 596 #undef _
 597 #define _(n,s) udp_add_dst_port (um, UDP_DST_PORT_##s, #s, 0 /* is_ip4 */);
 598     foreach_udp6_dst_port
 599 #undef _
 600     ip4_register_protocol (IP_PROTOCOL_UDP, udp4_local_node.index);
 601   /* Note: ip6 differs from ip4, UDP is hotwired to ip6-udp-lookup */
 602   return 0;
 603 }
 604
 605 VLIB_INIT_FUNCTION (udp_local_init);
 606 #endif /* CLIB_MARCH_VARIANT */
 607
 608 /*
 609  * fd.io coding-style-patch-verification: ON
 610  *
 611  * Local Variables:
 612  * eval: (c-set-style "gnu")
 613  * End:
 614  */