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