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