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