Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1 | /* |
AkshayaNadahalli | ed4a2fd | 2016-08-09 13:38:04 +0530 | [diff] [blame] | 2 | * Copyright (c) 2016 Cisco and/or its affiliates. |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | * you may not use this file except in compliance with the License. |
| 5 | * You may obtain a copy of the License at: |
| 6 | * |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | * |
| 9 | * Unless required by applicable law or agreed to in writing, software |
| 10 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | * See the License for the specific language governing permissions and |
| 13 | * limitations under the License. |
| 14 | */ |
| 15 | /* |
| 16 | * ip/ip6_forward.c: IP v6 forwarding |
| 17 | * |
| 18 | * Copyright (c) 2008 Eliot Dresselhaus |
| 19 | * |
| 20 | * Permission is hereby granted, free of charge, to any person obtaining |
| 21 | * a copy of this software and associated documentation files (the |
| 22 | * "Software"), to deal in the Software without restriction, including |
| 23 | * without limitation the rights to use, copy, modify, merge, publish, |
| 24 | * distribute, sublicense, and/or sell copies of the Software, and to |
| 25 | * permit persons to whom the Software is furnished to do so, subject to |
| 26 | * the following conditions: |
| 27 | * |
| 28 | * The above copyright notice and this permission notice shall be |
| 29 | * included in all copies or substantial portions of the Software. |
| 30 | * |
| 31 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 32 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 33 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| 34 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
| 35 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
| 36 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| 37 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 38 | */ |
| 39 | |
| 40 | #include <vnet/vnet.h> |
| 41 | #include <vnet/ip/ip.h> |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 42 | #include <vnet/ip/ip_frag.h> |
Pavel Kotucek | 9f5a2b6 | 2017-06-14 13:56:55 +0200 | [diff] [blame] | 43 | #include <vnet/ip/ip6_neighbor.h> |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 44 | #include <vnet/ethernet/ethernet.h> /* for ethernet_header_t */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 45 | #include <vnet/srp/srp.h> /* for srp_hw_interface_class */ |
| 46 | #include <vppinfra/cache.h> |
AkshayaNadahalli | 0f438df | 2017-02-10 10:54:16 +0530 | [diff] [blame] | 47 | #include <vnet/fib/fib_urpf_list.h> /* for FIB uRPF check */ |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 48 | #include <vnet/fib/ip6_fib.h> |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 49 | #include <vnet/mfib/ip6_mfib.h> |
Neale Ranns | f12a83f | 2017-04-18 09:09:40 -0700 | [diff] [blame] | 50 | #include <vnet/dpo/load_balance_map.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 51 | #include <vnet/dpo/classify_dpo.h> |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 52 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 53 | #ifndef CLIB_MARCH_VARIANT |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 54 | #include <vppinfra/bihash_template.c> |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 55 | #endif |
Vijayabhaskar Katamreddy | acbde66 | 2018-01-23 13:39:40 -0800 | [diff] [blame] | 56 | #include <vnet/ip/ip6_forward.h> |
Neale Ranns | 25edf14 | 2019-03-22 08:12:48 +0000 | [diff] [blame] | 57 | #include <vnet/interface_output.h> |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 58 | |
AkshayaNadahalli | fdd81af | 2016-12-01 16:33:51 +0530 | [diff] [blame] | 59 | /* Flag used by IOAM code. Classifier sets it pop-hop-by-hop checks it */ |
| 60 | #define OI_DECAP 0x80000000 |
| 61 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 62 | static void |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 63 | ip6_add_interface_prefix_routes (ip6_main_t * im, |
| 64 | u32 sw_if_index, |
| 65 | u32 fib_index, |
| 66 | ip6_address_t * address, u32 address_length) |
| 67 | { |
| 68 | ip_lookup_main_t *lm = &im->lookup_main; |
| 69 | ip_interface_prefix_t *if_prefix; |
| 70 | |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 71 | /* *INDENT-OFF* */ |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 72 | ip_interface_prefix_key_t key = { |
| 73 | .prefix = { |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 74 | .fp_len = address_length, |
| 75 | .fp_proto = FIB_PROTOCOL_IP6, |
| 76 | .fp_addr.ip6 = { |
| 77 | .as_u64 = { |
| 78 | address->as_u64[0] & im->fib_masks[address_length].as_u64[0], |
| 79 | address->as_u64[1] & im->fib_masks[address_length].as_u64[1], |
| 80 | }, |
| 81 | }, |
| 82 | }, |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 83 | .sw_if_index = sw_if_index, |
| 84 | }; |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 85 | /* *INDENT-ON* */ |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 86 | |
| 87 | /* If prefix already set on interface, just increment ref count & return */ |
| 88 | if_prefix = ip_get_interface_prefix (lm, &key); |
| 89 | if (if_prefix) |
| 90 | { |
| 91 | if_prefix->ref_count += 1; |
| 92 | return; |
| 93 | } |
| 94 | |
| 95 | /* New prefix - allocate a pool entry, initialize it, add to the hash */ |
| 96 | pool_get (lm->if_prefix_pool, if_prefix); |
| 97 | if_prefix->ref_count = 1; |
| 98 | clib_memcpy (&if_prefix->key, &key, sizeof (key)); |
| 99 | mhash_set (&lm->prefix_to_if_prefix_index, &key, |
| 100 | if_prefix - lm->if_prefix_pool, 0 /* old value */ ); |
| 101 | |
| 102 | /* length < 128 - add glean */ |
| 103 | if (address_length < 128) |
| 104 | { |
| 105 | /* set the glean route for the prefix */ |
| 106 | fib_table_entry_update_one_path (fib_index, &key.prefix, |
| 107 | FIB_SOURCE_INTERFACE, |
| 108 | (FIB_ENTRY_FLAG_CONNECTED | |
| 109 | FIB_ENTRY_FLAG_ATTACHED), |
| 110 | DPO_PROTO_IP6, |
| 111 | /* No next-hop address */ |
| 112 | NULL, sw_if_index, |
| 113 | /* invalid FIB index */ |
| 114 | ~0, 1, |
| 115 | /* no out-label stack */ |
| 116 | NULL, FIB_ROUTE_PATH_FLAG_NONE); |
| 117 | } |
| 118 | } |
| 119 | |
| 120 | static void |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 121 | ip6_add_interface_routes (vnet_main_t * vnm, u32 sw_if_index, |
| 122 | ip6_main_t * im, u32 fib_index, |
| 123 | ip_interface_address_t * a) |
| 124 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 125 | ip_lookup_main_t *lm = &im->lookup_main; |
| 126 | ip6_address_t *address = ip_interface_address_get_address (lm, a); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 127 | fib_prefix_t pfx = { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 128 | .fp_len = a->address_length, |
| 129 | .fp_proto = FIB_PROTOCOL_IP6, |
| 130 | .fp_addr.ip6 = *address, |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 131 | }; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 132 | |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 133 | /* set special routes for the prefix if needed */ |
| 134 | ip6_add_interface_prefix_routes (im, sw_if_index, fib_index, |
| 135 | address, a->address_length); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 136 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 137 | pfx.fp_len = 128; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 138 | if (sw_if_index < vec_len (lm->classify_table_index_by_sw_if_index)) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 139 | { |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 140 | u32 classify_table_index = |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 141 | lm->classify_table_index_by_sw_if_index[sw_if_index]; |
| 142 | if (classify_table_index != (u32) ~ 0) |
| 143 | { |
| 144 | dpo_id_t dpo = DPO_INVALID; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 145 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 146 | dpo_set (&dpo, |
| 147 | DPO_CLASSIFY, |
| 148 | DPO_PROTO_IP6, |
| 149 | classify_dpo_create (DPO_PROTO_IP6, classify_table_index)); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 150 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 151 | fib_table_entry_special_dpo_add (fib_index, |
| 152 | &pfx, |
| 153 | FIB_SOURCE_CLASSIFY, |
| 154 | FIB_ENTRY_FLAG_NONE, &dpo); |
| 155 | dpo_reset (&dpo); |
| 156 | } |
| 157 | } |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 158 | |
Neale Ranns | f12a83f | 2017-04-18 09:09:40 -0700 | [diff] [blame] | 159 | fib_table_entry_update_one_path (fib_index, &pfx, |
| 160 | FIB_SOURCE_INTERFACE, |
| 161 | (FIB_ENTRY_FLAG_CONNECTED | |
| 162 | FIB_ENTRY_FLAG_LOCAL), |
Neale Ranns | da78f95 | 2017-05-24 09:15:43 -0700 | [diff] [blame] | 163 | DPO_PROTO_IP6, |
Neale Ranns | f12a83f | 2017-04-18 09:09:40 -0700 | [diff] [blame] | 164 | &pfx.fp_addr, |
| 165 | sw_if_index, ~0, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 166 | 1, NULL, FIB_ROUTE_PATH_FLAG_NONE); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 167 | } |
| 168 | |
| 169 | static void |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 170 | ip6_del_interface_prefix_routes (ip6_main_t * im, |
| 171 | u32 sw_if_index, |
| 172 | u32 fib_index, |
| 173 | ip6_address_t * address, u32 address_length) |
| 174 | { |
| 175 | ip_lookup_main_t *lm = &im->lookup_main; |
| 176 | ip_interface_prefix_t *if_prefix; |
| 177 | |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 178 | /* *INDENT-OFF* */ |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 179 | ip_interface_prefix_key_t key = { |
| 180 | .prefix = { |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 181 | .fp_len = address_length, |
| 182 | .fp_proto = FIB_PROTOCOL_IP6, |
| 183 | .fp_addr.ip6 = { |
| 184 | .as_u64 = { |
| 185 | address->as_u64[0] & im->fib_masks[address_length].as_u64[0], |
| 186 | address->as_u64[1] & im->fib_masks[address_length].as_u64[1], |
| 187 | }, |
| 188 | }, |
| 189 | }, |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 190 | .sw_if_index = sw_if_index, |
| 191 | }; |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 192 | /* *INDENT-ON* */ |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 193 | |
| 194 | if_prefix = ip_get_interface_prefix (lm, &key); |
| 195 | if (!if_prefix) |
| 196 | { |
| 197 | clib_warning ("Prefix not found while deleting %U", |
| 198 | format_ip4_address_and_length, address, address_length); |
| 199 | return; |
| 200 | } |
| 201 | |
| 202 | /* If not deleting last intf addr in prefix, decrement ref count & return */ |
| 203 | if_prefix->ref_count -= 1; |
| 204 | if (if_prefix->ref_count > 0) |
| 205 | return; |
| 206 | |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 207 | /* length <= 128, delete glean route */ |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 208 | if (address_length <= 128) |
| 209 | { |
| 210 | /* remove glean route for prefix */ |
| 211 | fib_table_entry_delete (fib_index, &key.prefix, FIB_SOURCE_INTERFACE); |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | mhash_unset (&lm->prefix_to_if_prefix_index, &key, 0 /* old_value */ ); |
| 215 | pool_put (lm->if_prefix_pool, if_prefix); |
| 216 | } |
| 217 | |
| 218 | static void |
| 219 | ip6_del_interface_routes (u32 sw_if_index, ip6_main_t * im, |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 220 | u32 fib_index, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 221 | ip6_address_t * address, u32 address_length) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 222 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 223 | fib_prefix_t pfx = { |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 224 | .fp_len = 128, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 225 | .fp_proto = FIB_PROTOCOL_IP6, |
| 226 | .fp_addr.ip6 = *address, |
| 227 | }; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 228 | |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 229 | /* delete special routes for the prefix if needed */ |
| 230 | ip6_del_interface_prefix_routes (im, sw_if_index, fib_index, |
| 231 | address, address_length); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 232 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 233 | fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 234 | } |
| 235 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 236 | #ifndef CLIB_MARCH_VARIANT |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 237 | void |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 238 | ip6_sw_interface_enable_disable (u32 sw_if_index, u32 is_enable) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 239 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 240 | ip6_main_t *im = &ip6_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 241 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 242 | vec_validate_init_empty (im->ip_enabled_by_sw_if_index, sw_if_index, 0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 243 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 244 | /* |
| 245 | * enable/disable only on the 1<->0 transition |
| 246 | */ |
| 247 | if (is_enable) |
| 248 | { |
| 249 | if (1 != ++im->ip_enabled_by_sw_if_index[sw_if_index]) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 250 | return; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 251 | } |
| 252 | else |
| 253 | { |
Neale Ranns | 7515228 | 2017-01-09 01:00:45 -0800 | [diff] [blame] | 254 | /* The ref count is 0 when an address is removed from an interface that has |
| 255 | * no address - this is not a ciritical error */ |
| 256 | if (0 == im->ip_enabled_by_sw_if_index[sw_if_index] || |
| 257 | 0 != --im->ip_enabled_by_sw_if_index[sw_if_index]) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 258 | return; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 259 | } |
| 260 | |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 261 | vnet_feature_enable_disable ("ip6-unicast", "ip6-not-enabled", sw_if_index, |
Neale Ranns | 630198f | 2017-05-22 09:20:20 -0400 | [diff] [blame] | 262 | !is_enable, 0, 0); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 263 | |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 264 | vnet_feature_enable_disable ("ip6-multicast", "ip6-not-enabled", |
| 265 | sw_if_index, !is_enable, 0, 0); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 266 | } |
| 267 | |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 268 | /* get first interface address */ |
| 269 | ip6_address_t * |
Neale Ranns | 6cfc39c | 2017-02-14 01:44:25 -0800 | [diff] [blame] | 270 | ip6_interface_first_address (ip6_main_t * im, u32 sw_if_index) |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 271 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 272 | ip_lookup_main_t *lm = &im->lookup_main; |
| 273 | ip_interface_address_t *ia = 0; |
| 274 | ip6_address_t *result = 0; |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 275 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 276 | /* *INDENT-OFF* */ |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 277 | foreach_ip_interface_address (lm, ia, sw_if_index, |
| 278 | 1 /* honor unnumbered */, |
| 279 | ({ |
| 280 | ip6_address_t * a = ip_interface_address_get_address (lm, ia); |
| 281 | result = a; |
| 282 | break; |
| 283 | })); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 284 | /* *INDENT-ON* */ |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 285 | return result; |
| 286 | } |
| 287 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 288 | clib_error_t * |
| 289 | ip6_add_del_interface_address (vlib_main_t * vm, |
| 290 | u32 sw_if_index, |
| 291 | ip6_address_t * address, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 292 | u32 address_length, u32 is_del) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 293 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 294 | vnet_main_t *vnm = vnet_get_main (); |
| 295 | ip6_main_t *im = &ip6_main; |
| 296 | ip_lookup_main_t *lm = &im->lookup_main; |
| 297 | clib_error_t *error; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 298 | u32 if_address_index; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 299 | ip6_address_fib_t ip6_af, *addr_fib = 0; |
Juraj Sloboda | 5bb1eca | 2018-10-22 09:57:13 +0200 | [diff] [blame] | 300 | ip6_address_t ll_addr; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 301 | |
Pavel Kotucek | 5780898 | 2017-08-02 08:20:19 +0200 | [diff] [blame] | 302 | /* local0 interface doesn't support IP addressing */ |
| 303 | if (sw_if_index == 0) |
| 304 | { |
| 305 | return |
| 306 | clib_error_create ("local0 interface doesn't support IP addressing"); |
| 307 | } |
| 308 | |
Juraj Sloboda | 5bb1eca | 2018-10-22 09:57:13 +0200 | [diff] [blame] | 309 | if (ip6_address_is_link_local_unicast (address)) |
| 310 | { |
| 311 | if (address_length != 128) |
| 312 | { |
| 313 | vnm->api_errno = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH; |
| 314 | return |
| 315 | clib_error_create |
| 316 | ("prefix length of link-local address must be 128"); |
| 317 | } |
| 318 | if (!is_del) |
| 319 | { |
| 320 | return ip6_neighbor_set_link_local_address (vm, sw_if_index, |
| 321 | address); |
| 322 | } |
| 323 | else |
| 324 | { |
| 325 | ll_addr = ip6_neighbor_get_link_local_address (sw_if_index); |
| 326 | if (ip6_address_is_equal (&ll_addr, address)) |
| 327 | { |
| 328 | vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_DELETABLE; |
| 329 | return clib_error_create ("address not deletable"); |
| 330 | } |
| 331 | else |
| 332 | { |
| 333 | vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_FOUND_FOR_INTERFACE; |
| 334 | return clib_error_create ("address not found"); |
| 335 | } |
| 336 | } |
| 337 | } |
| 338 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 339 | vec_validate (im->fib_index_by_sw_if_index, sw_if_index); |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 340 | vec_validate (im->mfib_index_by_sw_if_index, sw_if_index); |
| 341 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 342 | ip6_addr_fib_init (&ip6_af, address, |
| 343 | vec_elt (im->fib_index_by_sw_if_index, sw_if_index)); |
| 344 | vec_add1 (addr_fib, ip6_af); |
| 345 | |
Neale Ranns | 744902e | 2017-08-14 10:35:44 -0700 | [diff] [blame] | 346 | /* *INDENT-OFF* */ |
| 347 | if (!is_del) |
| 348 | { |
| 349 | /* When adding an address check that it does not conflict |
| 350 | with an existing address on any interface in this table. */ |
| 351 | ip_interface_address_t *ia; |
| 352 | vnet_sw_interface_t *sif; |
| 353 | |
| 354 | pool_foreach(sif, vnm->interface_main.sw_interfaces, |
| 355 | ({ |
| 356 | if (im->fib_index_by_sw_if_index[sw_if_index] == |
| 357 | im->fib_index_by_sw_if_index[sif->sw_if_index]) |
| 358 | { |
| 359 | foreach_ip_interface_address |
| 360 | (&im->lookup_main, ia, sif->sw_if_index, |
| 361 | 0 /* honor unnumbered */ , |
| 362 | ({ |
| 363 | ip6_address_t * x = |
| 364 | ip_interface_address_get_address |
| 365 | (&im->lookup_main, ia); |
| 366 | if (ip6_destination_matches_route |
| 367 | (im, address, x, ia->address_length) || |
| 368 | ip6_destination_matches_route (im, |
| 369 | x, |
| 370 | address, |
| 371 | address_length)) |
| 372 | { |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 373 | /* an intf may have >1 addr from the same prefix */ |
| 374 | if ((sw_if_index == sif->sw_if_index) && |
| 375 | (ia->address_length == address_length) && |
| 376 | !ip6_address_is_equal (x, address)) |
| 377 | continue; |
| 378 | |
| 379 | /* error if the length or intf was different */ |
Neale Ranns | 744902e | 2017-08-14 10:35:44 -0700 | [diff] [blame] | 380 | vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS; |
| 381 | return |
| 382 | clib_error_create |
| 383 | ("failed to add %U which conflicts with %U for interface %U", |
| 384 | format_ip6_address_and_length, address, |
| 385 | address_length, |
| 386 | format_ip6_address_and_length, x, |
| 387 | ia->address_length, |
| 388 | format_vnet_sw_if_index_name, vnm, |
| 389 | sif->sw_if_index); |
| 390 | } |
| 391 | })); |
| 392 | } |
| 393 | })); |
| 394 | } |
| 395 | /* *INDENT-ON* */ |
| 396 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 397 | { |
| 398 | uword elts_before = pool_elts (lm->if_address_pool); |
| 399 | |
| 400 | error = ip_interface_address_add_del |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 401 | (lm, sw_if_index, addr_fib, address_length, is_del, &if_address_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 402 | if (error) |
| 403 | goto done; |
| 404 | |
| 405 | /* Pool did not grow: add duplicate address. */ |
| 406 | if (elts_before == pool_elts (lm->if_address_pool)) |
| 407 | goto done; |
| 408 | } |
| 409 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 410 | ip6_sw_interface_enable_disable (sw_if_index, !is_del); |
Neale Ranns | 177bbdc | 2016-11-15 09:46:51 +0000 | [diff] [blame] | 411 | |
Neale Ranns | 1ff3c15 | 2019-10-07 22:40:54 -0700 | [diff] [blame] | 412 | /* intf addr routes are added/deleted on admin up/down */ |
| 413 | if (vnet_sw_interface_is_admin_up (vnm, sw_if_index)) |
| 414 | { |
| 415 | if (is_del) |
| 416 | ip6_del_interface_routes (sw_if_index, |
| 417 | im, ip6_af.fib_index, address, |
| 418 | address_length); |
| 419 | else |
| 420 | ip6_add_interface_routes (vnm, sw_if_index, |
| 421 | im, ip6_af.fib_index, |
| 422 | pool_elt_at_index (lm->if_address_pool, |
| 423 | if_address_index)); |
| 424 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 425 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 426 | ip6_add_del_interface_address_callback_t *cb; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 427 | vec_foreach (cb, im->add_del_interface_address_callbacks) |
| 428 | cb->function (im, cb->function_opaque, sw_if_index, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 429 | address, address_length, if_address_index, is_del); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 430 | } |
| 431 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 432 | done: |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 433 | vec_free (addr_fib); |
| 434 | return error; |
| 435 | } |
| 436 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 437 | #endif |
| 438 | |
| 439 | static clib_error_t * |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 440 | ip6_sw_interface_admin_up_down (vnet_main_t * vnm, u32 sw_if_index, u32 flags) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 441 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 442 | ip6_main_t *im = &ip6_main; |
| 443 | ip_interface_address_t *ia; |
| 444 | ip6_address_t *a; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 445 | u32 is_admin_up, fib_index; |
| 446 | |
| 447 | /* Fill in lookup tables with default table (0). */ |
| 448 | vec_validate (im->fib_index_by_sw_if_index, sw_if_index); |
| 449 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 450 | vec_validate_init_empty (im-> |
| 451 | lookup_main.if_address_pool_index_by_sw_if_index, |
| 452 | sw_if_index, ~0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 453 | |
| 454 | is_admin_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0; |
| 455 | |
| 456 | fib_index = vec_elt (im->fib_index_by_sw_if_index, sw_if_index); |
| 457 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 458 | /* *INDENT-OFF* */ |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 459 | foreach_ip_interface_address (&im->lookup_main, ia, sw_if_index, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 460 | 0 /* honor unnumbered */, |
| 461 | ({ |
| 462 | a = ip_interface_address_get_address (&im->lookup_main, ia); |
| 463 | if (is_admin_up) |
| 464 | ip6_add_interface_routes (vnm, sw_if_index, |
| 465 | im, fib_index, |
| 466 | ia); |
| 467 | else |
Matthew Smith | 6c92f5b | 2019-08-07 11:46:30 -0500 | [diff] [blame] | 468 | ip6_del_interface_routes (sw_if_index, im, fib_index, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 469 | a, ia->address_length); |
| 470 | })); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 471 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 472 | |
| 473 | return 0; |
| 474 | } |
| 475 | |
| 476 | VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (ip6_sw_interface_admin_up_down); |
| 477 | |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 478 | /* Built-in ip6 unicast rx feature path definition */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 479 | /* *INDENT-OFF* */ |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 480 | VNET_FEATURE_ARC_INIT (ip6_unicast, static) = |
| 481 | { |
| 482 | .arc_name = "ip6-unicast", |
| 483 | .start_nodes = VNET_FEATURES ("ip6-input"), |
Dave Barach | a25def7 | 2018-11-26 11:04:45 -0500 | [diff] [blame] | 484 | .last_in_arc = "ip6-lookup", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 485 | .arc_index_ptr = &ip6_main.lookup_main.ucast_feature_arc_index, |
| 486 | }; |
| 487 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 488 | VNET_FEATURE_INIT (ip6_flow_classify, static) = |
| 489 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 490 | .arc_name = "ip6-unicast", |
Juraj Sloboda | 506b245 | 2016-08-07 23:45:24 -0700 | [diff] [blame] | 491 | .node_name = "ip6-flow-classify", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 492 | .runs_before = VNET_FEATURES ("ip6-inacl"), |
Juraj Sloboda | 506b245 | 2016-08-07 23:45:24 -0700 | [diff] [blame] | 493 | }; |
| 494 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 495 | VNET_FEATURE_INIT (ip6_inacl, static) = |
| 496 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 497 | .arc_name = "ip6-unicast", |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 498 | .node_name = "ip6-inacl", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 499 | .runs_before = VNET_FEATURES ("ip6-policer-classify"), |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 500 | }; |
| 501 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 502 | VNET_FEATURE_INIT (ip6_policer_classify, static) = |
| 503 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 504 | .arc_name = "ip6-unicast", |
Matus Fabian | 70e6a8d | 2016-06-20 08:10:42 -0700 | [diff] [blame] | 505 | .node_name = "ip6-policer-classify", |
Pierre Pfister | 057b356 | 2018-12-10 17:01:01 +0100 | [diff] [blame] | 506 | .runs_before = VNET_FEATURES ("ipsec6-input-feature"), |
Matus Fabian | 70e6a8d | 2016-06-20 08:10:42 -0700 | [diff] [blame] | 507 | }; |
| 508 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 509 | VNET_FEATURE_INIT (ip6_ipsec, static) = |
| 510 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 511 | .arc_name = "ip6-unicast", |
Pierre Pfister | 057b356 | 2018-12-10 17:01:01 +0100 | [diff] [blame] | 512 | .node_name = "ipsec6-input-feature", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 513 | .runs_before = VNET_FEATURES ("l2tp-decap"), |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 514 | }; |
| 515 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 516 | VNET_FEATURE_INIT (ip6_l2tp, static) = |
| 517 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 518 | .arc_name = "ip6-unicast", |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 519 | .node_name = "l2tp-decap", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 520 | .runs_before = VNET_FEATURES ("vpath-input-ip6"), |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 521 | }; |
| 522 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 523 | VNET_FEATURE_INIT (ip6_vpath, static) = |
| 524 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 525 | .arc_name = "ip6-unicast", |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 526 | .node_name = "vpath-input-ip6", |
John Lo | 2b81eb8 | 2017-01-30 13:12:10 -0500 | [diff] [blame] | 527 | .runs_before = VNET_FEATURES ("ip6-vxlan-bypass"), |
| 528 | }; |
| 529 | |
| 530 | VNET_FEATURE_INIT (ip6_vxlan_bypass, static) = |
| 531 | { |
| 532 | .arc_name = "ip6-unicast", |
| 533 | .node_name = "ip6-vxlan-bypass", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 534 | .runs_before = VNET_FEATURES ("ip6-lookup"), |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 535 | }; |
| 536 | |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 537 | VNET_FEATURE_INIT (ip6_not_enabled, static) = |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 538 | { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 539 | .arc_name = "ip6-unicast", |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 540 | .node_name = "ip6-not-enabled", |
Neale Ranns | 630198f | 2017-05-22 09:20:20 -0400 | [diff] [blame] | 541 | .runs_before = VNET_FEATURES ("ip6-lookup"), |
| 542 | }; |
| 543 | |
| 544 | VNET_FEATURE_INIT (ip6_lookup, static) = |
| 545 | { |
| 546 | .arc_name = "ip6-unicast", |
| 547 | .node_name = "ip6-lookup", |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 548 | .runs_before = 0, /*last feature*/ |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 549 | }; |
| 550 | |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 551 | /* Built-in ip6 multicast rx feature path definition (none now) */ |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 552 | VNET_FEATURE_ARC_INIT (ip6_multicast, static) = |
| 553 | { |
| 554 | .arc_name = "ip6-multicast", |
| 555 | .start_nodes = VNET_FEATURES ("ip6-input"), |
Dave Barach | a25def7 | 2018-11-26 11:04:45 -0500 | [diff] [blame] | 556 | .last_in_arc = "ip6-mfib-forward-lookup", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 557 | .arc_index_ptr = &ip6_main.lookup_main.mcast_feature_arc_index, |
| 558 | }; |
| 559 | |
| 560 | VNET_FEATURE_INIT (ip6_vpath_mc, static) = { |
| 561 | .arc_name = "ip6-multicast", |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 562 | .node_name = "vpath-input-ip6", |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 563 | .runs_before = VNET_FEATURES ("ip6-mfib-forward-lookup"), |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 564 | }; |
| 565 | |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 566 | VNET_FEATURE_INIT (ip6_not_enabled_mc, static) = { |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 567 | .arc_name = "ip6-multicast", |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 568 | .node_name = "ip6-not-enabled", |
Neale Ranns | 630198f | 2017-05-22 09:20:20 -0400 | [diff] [blame] | 569 | .runs_before = VNET_FEATURES ("ip6-mfib-forward-lookup"), |
| 570 | }; |
| 571 | |
| 572 | VNET_FEATURE_INIT (ip6_mc_lookup, static) = { |
| 573 | .arc_name = "ip6-multicast", |
| 574 | .node_name = "ip6-mfib-forward-lookup", |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 575 | .runs_before = 0, /* last feature */ |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 576 | }; |
Dave Barach | 5331c72 | 2016-08-17 11:54:30 -0400 | [diff] [blame] | 577 | |
| 578 | /* Built-in ip4 tx feature path definition */ |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 579 | VNET_FEATURE_ARC_INIT (ip6_output, static) = |
| 580 | { |
| 581 | .arc_name = "ip6-output", |
Neale Ranns | f068c3e | 2018-01-03 04:18:48 -0800 | [diff] [blame] | 582 | .start_nodes = VNET_FEATURES ("ip6-rewrite", "ip6-midchain", "ip6-dvr-dpo"), |
Dave Barach | a25def7 | 2018-11-26 11:04:45 -0500 | [diff] [blame] | 583 | .last_in_arc = "interface-output", |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 584 | .arc_index_ptr = &ip6_main.lookup_main.output_feature_arc_index, |
Dave Barach | 5331c72 | 2016-08-17 11:54:30 -0400 | [diff] [blame] | 585 | }; |
| 586 | |
Andrew Yourtchenko | 815d7d5 | 2018-02-07 11:37:02 +0100 | [diff] [blame] | 587 | VNET_FEATURE_INIT (ip6_outacl, static) = { |
| 588 | .arc_name = "ip6-output", |
| 589 | .node_name = "ip6-outacl", |
Pierre Pfister | 057b356 | 2018-12-10 17:01:01 +0100 | [diff] [blame] | 590 | .runs_before = VNET_FEATURES ("ipsec6-output-feature"), |
Andrew Yourtchenko | 815d7d5 | 2018-02-07 11:37:02 +0100 | [diff] [blame] | 591 | }; |
| 592 | |
Matus Fabian | 08a6f01 | 2016-11-15 06:08:51 -0800 | [diff] [blame] | 593 | VNET_FEATURE_INIT (ip6_ipsec_output, static) = { |
| 594 | .arc_name = "ip6-output", |
Pierre Pfister | 057b356 | 2018-12-10 17:01:01 +0100 | [diff] [blame] | 595 | .node_name = "ipsec6-output-feature", |
Matus Fabian | 08a6f01 | 2016-11-15 06:08:51 -0800 | [diff] [blame] | 596 | .runs_before = VNET_FEATURES ("interface-output"), |
| 597 | }; |
| 598 | |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 599 | VNET_FEATURE_INIT (ip6_interface_output, static) = { |
| 600 | .arc_name = "ip6-output", |
| 601 | .node_name = "interface-output", |
| 602 | .runs_before = 0, /* not before any other features */ |
| 603 | }; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 604 | /* *INDENT-ON* */ |
Dave Barach | d653460 | 2016-06-14 18:38:02 -0400 | [diff] [blame] | 605 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 606 | static clib_error_t * |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 607 | ip6_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 608 | { |
Florin Coras | b5c13fd | 2017-05-10 12:32:53 -0700 | [diff] [blame] | 609 | ip6_main_t *im = &ip6_main; |
| 610 | |
| 611 | vec_validate (im->fib_index_by_sw_if_index, sw_if_index); |
| 612 | vec_validate (im->mfib_index_by_sw_if_index, sw_if_index); |
| 613 | |
Pavel Kotucek | 9f5a2b6 | 2017-06-14 13:56:55 +0200 | [diff] [blame] | 614 | if (!is_add) |
| 615 | { |
| 616 | /* Ensure that IPv6 is disabled */ |
| 617 | ip6_main_t *im6 = &ip6_main; |
| 618 | ip_lookup_main_t *lm6 = &im6->lookup_main; |
| 619 | ip_interface_address_t *ia = 0; |
| 620 | ip6_address_t *address; |
| 621 | vlib_main_t *vm = vlib_get_main (); |
| 622 | |
| 623 | ip6_neighbor_sw_interface_add_del (vnm, sw_if_index, 0 /* is_add */ ); |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 624 | vnet_sw_interface_update_unnumbered (sw_if_index, ~0, 0); |
Pavel Kotucek | 9f5a2b6 | 2017-06-14 13:56:55 +0200 | [diff] [blame] | 625 | /* *INDENT-OFF* */ |
Neale Ranns | 2ae2bc5 | 2018-03-16 03:22:39 -0700 | [diff] [blame] | 626 | foreach_ip_interface_address (lm6, ia, sw_if_index, 0, |
Pavel Kotucek | 9f5a2b6 | 2017-06-14 13:56:55 +0200 | [diff] [blame] | 627 | ({ |
| 628 | address = ip_interface_address_get_address (lm6, ia); |
| 629 | ip6_add_del_interface_address(vm, sw_if_index, address, ia->address_length, 1); |
| 630 | })); |
| 631 | /* *INDENT-ON* */ |
| 632 | ip6_mfib_interface_enable_disable (sw_if_index, 0); |
| 633 | } |
| 634 | |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 635 | vnet_feature_enable_disable ("ip6-unicast", "ip6-not-enabled", sw_if_index, |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 636 | is_add, 0, 0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 637 | |
Neale Ranns | 8269d3d | 2018-01-30 09:02:20 -0800 | [diff] [blame] | 638 | vnet_feature_enable_disable ("ip6-multicast", "ip6-not-enabled", |
| 639 | sw_if_index, is_add, 0, 0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 640 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 641 | return /* no error */ 0; |
| 642 | } |
| 643 | |
| 644 | VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip6_sw_interface_add_del); |
| 645 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 646 | VLIB_NODE_FN (ip6_lookup_node) (vlib_main_t * vm, |
| 647 | vlib_node_runtime_t * node, |
| 648 | vlib_frame_t * frame) |
Damjan Marion | aca64c9 | 2016-04-13 09:48:56 +0200 | [diff] [blame] | 649 | { |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 650 | return ip6_lookup_inline (vm, node, frame); |
Damjan Marion | aca64c9 | 2016-04-13 09:48:56 +0200 | [diff] [blame] | 651 | } |
| 652 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 653 | static u8 *format_ip6_lookup_trace (u8 * s, va_list * args); |
Pierre Pfister | 0febaf1 | 2016-06-08 12:23:21 +0100 | [diff] [blame] | 654 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 655 | /* *INDENT-OFF* */ |
| 656 | VLIB_REGISTER_NODE (ip6_lookup_node) = |
| 657 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 658 | .name = "ip6-lookup", |
| 659 | .vector_size = sizeof (u32), |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 660 | .format_trace = format_ip6_lookup_trace, |
Ole Troan | f0f8522 | 2016-06-14 21:12:32 +0200 | [diff] [blame] | 661 | .n_next_nodes = IP6_LOOKUP_N_NEXT, |
Damjan Marion | b270789 | 2016-04-13 11:21:07 +0200 | [diff] [blame] | 662 | .next_nodes = IP6_LOOKUP_NEXT_NODES, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 663 | }; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 664 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 665 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 666 | VLIB_NODE_FN (ip6_load_balance_node) (vlib_main_t * vm, |
| 667 | vlib_node_runtime_t * node, |
| 668 | vlib_frame_t * frame) |
Damjan Marion | aca64c9 | 2016-04-13 09:48:56 +0200 | [diff] [blame] | 669 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 670 | vlib_combined_counter_main_t *cm = &load_balance_main.lbm_via_counters; |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 671 | u32 n_left, *from; |
Damjan Marion | 067cd62 | 2018-07-11 12:47:43 +0200 | [diff] [blame] | 672 | u32 thread_index = vm->thread_index; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 673 | ip6_main_t *im = &ip6_main; |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 674 | vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs; |
| 675 | u16 nexts[VLIB_FRAME_SIZE], *next; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 676 | |
| 677 | from = vlib_frame_vector_args (frame); |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 678 | n_left = frame->n_vectors; |
| 679 | next = nexts; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 680 | |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 681 | vlib_get_buffers (vm, from, bufs, n_left); |
| 682 | |
| 683 | while (n_left >= 4) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 684 | { |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 685 | const load_balance_t *lb0, *lb1; |
| 686 | const ip6_header_t *ip0, *ip1; |
| 687 | u32 lbi0, hc0, lbi1, hc1; |
| 688 | const dpo_id_t *dpo0, *dpo1; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 689 | |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 690 | /* Prefetch next iteration. */ |
| 691 | { |
| 692 | vlib_prefetch_buffer_header (b[2], STORE); |
| 693 | vlib_prefetch_buffer_header (b[3], STORE); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 694 | |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 695 | CLIB_PREFETCH (b[2]->data, sizeof (ip0[0]), STORE); |
| 696 | CLIB_PREFETCH (b[3]->data, sizeof (ip0[0]), STORE); |
| 697 | } |
| 698 | |
| 699 | ip0 = vlib_buffer_get_current (b[0]); |
| 700 | ip1 = vlib_buffer_get_current (b[1]); |
| 701 | lbi0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX]; |
| 702 | lbi1 = vnet_buffer (b[1])->ip.adj_index[VLIB_TX]; |
| 703 | |
| 704 | lb0 = load_balance_get (lbi0); |
| 705 | lb1 = load_balance_get (lbi1); |
| 706 | |
| 707 | /* |
| 708 | * this node is for via FIBs we can re-use the hash value from the |
| 709 | * to node if present. |
| 710 | * We don't want to use the same hash value at each level in the recursion |
| 711 | * graph as that would lead to polarisation |
| 712 | */ |
| 713 | hc0 = hc1 = 0; |
| 714 | |
| 715 | if (PREDICT_FALSE (lb0->lb_n_buckets > 1)) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 716 | { |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 717 | if (PREDICT_TRUE (vnet_buffer (b[0])->ip.flow_hash)) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 718 | { |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 719 | hc0 = vnet_buffer (b[0])->ip.flow_hash = |
| 720 | vnet_buffer (b[0])->ip.flow_hash >> 1; |
Neale Ranns | f12a83f | 2017-04-18 09:09:40 -0700 | [diff] [blame] | 721 | } |
| 722 | else |
| 723 | { |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 724 | hc0 = vnet_buffer (b[0])->ip.flow_hash = |
| 725 | ip6_compute_flow_hash (ip0, lb0->lb_hash_config); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 726 | } |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 727 | dpo0 = load_balance_get_fwd_bucket |
| 728 | (lb0, (hc0 & (lb0->lb_n_buckets_minus_1))); |
| 729 | } |
| 730 | else |
| 731 | { |
| 732 | dpo0 = load_balance_get_bucket_i (lb0, 0); |
| 733 | } |
| 734 | if (PREDICT_FALSE (lb1->lb_n_buckets > 1)) |
| 735 | { |
| 736 | if (PREDICT_TRUE (vnet_buffer (b[1])->ip.flow_hash)) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 737 | { |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 738 | hc1 = vnet_buffer (b[1])->ip.flow_hash = |
| 739 | vnet_buffer (b[1])->ip.flow_hash >> 1; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 740 | } |
Neale Ranns | f12a83f | 2017-04-18 09:09:40 -0700 | [diff] [blame] | 741 | else |
| 742 | { |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 743 | hc1 = vnet_buffer (b[1])->ip.flow_hash = |
| 744 | ip6_compute_flow_hash (ip1, lb1->lb_hash_config); |
Neale Ranns | f12a83f | 2017-04-18 09:09:40 -0700 | [diff] [blame] | 745 | } |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 746 | dpo1 = load_balance_get_fwd_bucket |
| 747 | (lb1, (hc1 & (lb1->lb_n_buckets_minus_1))); |
| 748 | } |
| 749 | else |
| 750 | { |
| 751 | dpo1 = load_balance_get_bucket_i (lb1, 0); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 752 | } |
Neale Ranns | 2be95c1 | 2016-11-19 13:50:04 +0000 | [diff] [blame] | 753 | |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 754 | next[0] = dpo0->dpoi_next_node; |
| 755 | next[1] = dpo1->dpoi_next_node; |
| 756 | |
| 757 | /* Only process the HBH Option Header if explicitly configured to do so */ |
| 758 | if (PREDICT_FALSE (ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS)) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 759 | { |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 760 | next[0] = (dpo_is_adj (dpo0) && im->hbh_enabled) ? |
| 761 | (ip_lookup_next_t) IP6_LOOKUP_NEXT_HOP_BY_HOP : next[0]; |
| 762 | } |
| 763 | /* Only process the HBH Option Header if explicitly configured to do so */ |
| 764 | if (PREDICT_FALSE (ip1->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS)) |
| 765 | { |
| 766 | next[1] = (dpo_is_adj (dpo1) && im->hbh_enabled) ? |
| 767 | (ip_lookup_next_t) IP6_LOOKUP_NEXT_HOP_BY_HOP : next[1]; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 768 | } |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 769 | |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 770 | vnet_buffer (b[0])->ip.adj_index[VLIB_TX] = dpo0->dpoi_index; |
| 771 | vnet_buffer (b[1])->ip.adj_index[VLIB_TX] = dpo1->dpoi_index; |
| 772 | |
| 773 | vlib_increment_combined_counter |
| 774 | (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, b[0])); |
| 775 | vlib_increment_combined_counter |
| 776 | (cm, thread_index, lbi1, 1, vlib_buffer_length_in_chain (vm, b[1])); |
| 777 | |
| 778 | b += 2; |
| 779 | next += 2; |
| 780 | n_left -= 2; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 781 | } |
| 782 | |
Neale Ranns | 3ce72b2 | 2019-05-27 08:21:32 -0400 | [diff] [blame] | 783 | while (n_left > 0) |
| 784 | { |
| 785 | const load_balance_t *lb0; |
| 786 | const ip6_header_t *ip0; |
| 787 | const dpo_id_t *dpo0; |
| 788 | u32 lbi0, hc0; |
| 789 | |
| 790 | ip0 = vlib_buffer_get_current (b[0]); |
| 791 | lbi0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX]; |
| 792 | |
| 793 | lb0 = load_balance_get (lbi0); |
| 794 | |
| 795 | hc0 = 0; |
| 796 | if (PREDICT_FALSE (lb0->lb_n_buckets > 1)) |
| 797 | { |
| 798 | if (PREDICT_TRUE (vnet_buffer (b[0])->ip.flow_hash)) |
| 799 | { |
| 800 | hc0 = vnet_buffer (b[0])->ip.flow_hash = |
| 801 | vnet_buffer (b[0])->ip.flow_hash >> 1; |
| 802 | } |
| 803 | else |
| 804 | { |
| 805 | hc0 = vnet_buffer (b[0])->ip.flow_hash = |
| 806 | ip6_compute_flow_hash (ip0, lb0->lb_hash_config); |
| 807 | } |
| 808 | dpo0 = load_balance_get_fwd_bucket |
| 809 | (lb0, (hc0 & (lb0->lb_n_buckets_minus_1))); |
| 810 | } |
| 811 | else |
| 812 | { |
| 813 | dpo0 = load_balance_get_bucket_i (lb0, 0); |
| 814 | } |
| 815 | |
| 816 | next[0] = dpo0->dpoi_next_node; |
| 817 | vnet_buffer (b[0])->ip.adj_index[VLIB_TX] = dpo0->dpoi_index; |
| 818 | |
| 819 | /* Only process the HBH Option Header if explicitly configured to do so */ |
| 820 | if (PREDICT_FALSE (ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS)) |
| 821 | { |
| 822 | next[0] = (dpo_is_adj (dpo0) && im->hbh_enabled) ? |
| 823 | (ip_lookup_next_t) IP6_LOOKUP_NEXT_HOP_BY_HOP : next[0]; |
| 824 | } |
| 825 | |
| 826 | vlib_increment_combined_counter |
| 827 | (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, b[0])); |
| 828 | |
| 829 | b += 1; |
| 830 | next += 1; |
| 831 | n_left -= 1; |
| 832 | } |
| 833 | |
| 834 | vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors); |
| 835 | |
Neale Ranns | a71844f | 2018-11-08 07:31:36 -0800 | [diff] [blame] | 836 | if (node->flags & VLIB_NODE_FLAG_TRACE) |
| 837 | ip6_forward_next_trace (vm, node, frame, VLIB_TX); |
| 838 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 839 | return frame->n_vectors; |
Damjan Marion | aca64c9 | 2016-04-13 09:48:56 +0200 | [diff] [blame] | 840 | } |
| 841 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 842 | /* *INDENT-OFF* */ |
| 843 | VLIB_REGISTER_NODE (ip6_load_balance_node) = |
| 844 | { |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 845 | .name = "ip6-load-balance", |
Damjan Marion | aca64c9 | 2016-04-13 09:48:56 +0200 | [diff] [blame] | 846 | .vector_size = sizeof (u32), |
Ole Troan | f0f8522 | 2016-06-14 21:12:32 +0200 | [diff] [blame] | 847 | .sibling_of = "ip6-lookup", |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 848 | .format_trace = format_ip6_lookup_trace, |
Damjan Marion | aca64c9 | 2016-04-13 09:48:56 +0200 | [diff] [blame] | 849 | }; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 850 | /* *INDENT-ON* */ |
Damjan Marion | aca64c9 | 2016-04-13 09:48:56 +0200 | [diff] [blame] | 851 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 852 | typedef struct |
| 853 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 854 | /* Adjacency taken. */ |
| 855 | u32 adj_index; |
| 856 | u32 flow_hash; |
John Lo | 2d34374 | 2016-01-19 17:27:17 -0500 | [diff] [blame] | 857 | u32 fib_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 858 | |
| 859 | /* Packet data, possibly *after* rewrite. */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 860 | u8 packet_data[128 - 1 * sizeof (u32)]; |
| 861 | } |
| 862 | ip6_forward_next_trace_t; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 863 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 864 | #ifndef CLIB_MARCH_VARIANT |
John Lo | 2b81eb8 | 2017-01-30 13:12:10 -0500 | [diff] [blame] | 865 | u8 * |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 866 | format_ip6_forward_next_trace (u8 * s, va_list * args) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 867 | { |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 868 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 869 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 870 | ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *); |
Christophe Fontaine | d3c008d | 2017-10-02 18:10:54 +0200 | [diff] [blame] | 871 | u32 indent = format_get_indent (s); |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 872 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 873 | s = format (s, "%U%U", |
| 874 | format_white_space, indent, |
| 875 | format_ip6_header, t->packet_data, sizeof (t->packet_data)); |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 876 | return s; |
| 877 | } |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 878 | #endif |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 879 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 880 | static u8 * |
| 881 | format_ip6_lookup_trace (u8 * s, va_list * args) |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 882 | { |
| 883 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 884 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 885 | ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *); |
Christophe Fontaine | d3c008d | 2017-10-02 18:10:54 +0200 | [diff] [blame] | 886 | u32 indent = format_get_indent (s); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 887 | |
John Lo | ac8146c | 2016-09-27 17:44:02 -0400 | [diff] [blame] | 888 | s = format (s, "fib %d dpo-idx %d flow hash: 0x%08x", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 889 | t->fib_index, t->adj_index, t->flow_hash); |
| 890 | s = format (s, "\n%U%U", |
| 891 | format_white_space, indent, |
| 892 | format_ip6_header, t->packet_data, sizeof (t->packet_data)); |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 893 | return s; |
| 894 | } |
Pierre Pfister | 0febaf1 | 2016-06-08 12:23:21 +0100 | [diff] [blame] | 895 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 896 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 897 | static u8 * |
| 898 | format_ip6_rewrite_trace (u8 * s, va_list * args) |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 899 | { |
| 900 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 901 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 902 | ip6_forward_next_trace_t *t = va_arg (*args, ip6_forward_next_trace_t *); |
Christophe Fontaine | d3c008d | 2017-10-02 18:10:54 +0200 | [diff] [blame] | 903 | u32 indent = format_get_indent (s); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 904 | |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 905 | s = format (s, "tx_sw_if_index %d adj-idx %d : %U flow hash: 0x%08x", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 906 | t->fib_index, t->adj_index, format_ip_adjacency, |
| 907 | t->adj_index, FORMAT_IP_ADJACENCY_NONE, t->flow_hash); |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 908 | s = format (s, "\n%U%U", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 909 | format_white_space, indent, |
| 910 | format_ip_adjacency_packet_data, |
Neale Ranns | 0b6a857 | 2019-10-30 17:34:14 +0000 | [diff] [blame] | 911 | t->packet_data, sizeof (t->packet_data)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 912 | return s; |
| 913 | } |
| 914 | |
| 915 | /* Common trace function for all ip6-forward next nodes. */ |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 916 | #ifndef CLIB_MARCH_VARIANT |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 917 | void |
| 918 | ip6_forward_next_trace (vlib_main_t * vm, |
| 919 | vlib_node_runtime_t * node, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 920 | vlib_frame_t * frame, vlib_rx_or_tx_t which_adj_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 921 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 922 | u32 *from, n_left; |
| 923 | ip6_main_t *im = &ip6_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 924 | |
| 925 | n_left = frame->n_vectors; |
| 926 | from = vlib_frame_vector_args (frame); |
Pierre Pfister | 0febaf1 | 2016-06-08 12:23:21 +0100 | [diff] [blame] | 927 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 928 | while (n_left >= 4) |
| 929 | { |
| 930 | u32 bi0, bi1; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 931 | vlib_buffer_t *b0, *b1; |
| 932 | ip6_forward_next_trace_t *t0, *t1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 933 | |
| 934 | /* Prefetch next iteration. */ |
| 935 | vlib_prefetch_buffer_with_index (vm, from[2], LOAD); |
| 936 | vlib_prefetch_buffer_with_index (vm, from[3], LOAD); |
| 937 | |
| 938 | bi0 = from[0]; |
| 939 | bi1 = from[1]; |
| 940 | |
| 941 | b0 = vlib_get_buffer (vm, bi0); |
| 942 | b1 = vlib_get_buffer (vm, bi1); |
| 943 | |
| 944 | if (b0->flags & VLIB_BUFFER_IS_TRACED) |
| 945 | { |
| 946 | t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0])); |
| 947 | t0->adj_index = vnet_buffer (b0)->ip.adj_index[which_adj_index]; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 948 | t0->flow_hash = vnet_buffer (b0)->ip.flow_hash; |
| 949 | t0->fib_index = |
| 950 | (vnet_buffer (b0)->sw_if_index[VLIB_TX] != |
| 951 | (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] : |
| 952 | vec_elt (im->fib_index_by_sw_if_index, |
| 953 | vnet_buffer (b0)->sw_if_index[VLIB_RX]); |
Pierre Pfister | 0febaf1 | 2016-06-08 12:23:21 +0100 | [diff] [blame] | 954 | |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 955 | clib_memcpy_fast (t0->packet_data, |
| 956 | vlib_buffer_get_current (b0), |
| 957 | sizeof (t0->packet_data)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 958 | } |
| 959 | if (b1->flags & VLIB_BUFFER_IS_TRACED) |
| 960 | { |
| 961 | t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0])); |
| 962 | t1->adj_index = vnet_buffer (b1)->ip.adj_index[which_adj_index]; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 963 | t1->flow_hash = vnet_buffer (b1)->ip.flow_hash; |
| 964 | t1->fib_index = |
| 965 | (vnet_buffer (b1)->sw_if_index[VLIB_TX] != |
| 966 | (u32) ~ 0) ? vnet_buffer (b1)->sw_if_index[VLIB_TX] : |
| 967 | vec_elt (im->fib_index_by_sw_if_index, |
| 968 | vnet_buffer (b1)->sw_if_index[VLIB_RX]); |
Pierre Pfister | 0febaf1 | 2016-06-08 12:23:21 +0100 | [diff] [blame] | 969 | |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 970 | clib_memcpy_fast (t1->packet_data, |
| 971 | vlib_buffer_get_current (b1), |
| 972 | sizeof (t1->packet_data)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 973 | } |
| 974 | from += 2; |
| 975 | n_left -= 2; |
| 976 | } |
| 977 | |
| 978 | while (n_left >= 1) |
| 979 | { |
| 980 | u32 bi0; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 981 | vlib_buffer_t *b0; |
| 982 | ip6_forward_next_trace_t *t0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 983 | |
| 984 | bi0 = from[0]; |
| 985 | |
| 986 | b0 = vlib_get_buffer (vm, bi0); |
| 987 | |
| 988 | if (b0->flags & VLIB_BUFFER_IS_TRACED) |
| 989 | { |
| 990 | t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0])); |
| 991 | t0->adj_index = vnet_buffer (b0)->ip.adj_index[which_adj_index]; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 992 | t0->flow_hash = vnet_buffer (b0)->ip.flow_hash; |
| 993 | t0->fib_index = |
| 994 | (vnet_buffer (b0)->sw_if_index[VLIB_TX] != |
| 995 | (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] : |
| 996 | vec_elt (im->fib_index_by_sw_if_index, |
| 997 | vnet_buffer (b0)->sw_if_index[VLIB_RX]); |
Pierre Pfister | 0febaf1 | 2016-06-08 12:23:21 +0100 | [diff] [blame] | 998 | |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 999 | clib_memcpy_fast (t0->packet_data, |
| 1000 | vlib_buffer_get_current (b0), |
| 1001 | sizeof (t0->packet_data)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1002 | } |
| 1003 | from += 1; |
| 1004 | n_left -= 1; |
| 1005 | } |
| 1006 | } |
| 1007 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1008 | /* Compute TCP/UDP/ICMP6 checksum in software. */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1009 | u16 |
| 1010 | ip6_tcp_udp_icmp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0, |
| 1011 | ip6_header_t * ip0, int *bogus_lengthp) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1012 | { |
| 1013 | ip_csum_t sum0; |
Srikanth A | 02833ff | 2019-10-02 17:48:58 -0700 | [diff] [blame] | 1014 | u16 payload_length_host_byte_order; |
| 1015 | u32 i; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1016 | u32 headers_size = sizeof (ip0[0]); |
Dave Barach | c4abafd | 2019-09-04 12:09:32 -0400 | [diff] [blame] | 1017 | u8 *data_this_buffer; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1018 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1019 | ASSERT (bogus_lengthp); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1020 | *bogus_lengthp = 0; |
| 1021 | |
| 1022 | /* Initialize checksum with ip header. */ |
| 1023 | sum0 = ip0->payload_length + clib_host_to_net_u16 (ip0->protocol); |
| 1024 | payload_length_host_byte_order = clib_net_to_host_u16 (ip0->payload_length); |
Dave Barach | c4abafd | 2019-09-04 12:09:32 -0400 | [diff] [blame] | 1025 | data_this_buffer = (u8 *) (ip0 + 1); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1026 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1027 | for (i = 0; i < ARRAY_LEN (ip0->src_address.as_uword); i++) |
| 1028 | { |
Srikanth A | 02833ff | 2019-10-02 17:48:58 -0700 | [diff] [blame] | 1029 | sum0 = ip_csum_with_carry |
| 1030 | (sum0, clib_mem_unaligned (&ip0->src_address.as_uword[i], uword)); |
| 1031 | sum0 = ip_csum_with_carry |
| 1032 | (sum0, clib_mem_unaligned (&ip0->dst_address.as_uword[i], uword)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1033 | } |
| 1034 | |
AkshayaNadahalli | 1b56352 | 2017-01-23 22:05:35 +0530 | [diff] [blame] | 1035 | /* some icmp packets may come with a "router alert" hop-by-hop extension header (e.g., mldv2 packets) |
| 1036 | * or UDP-Ping packets */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1037 | if (PREDICT_FALSE (ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1038 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1039 | u32 skip_bytes; |
| 1040 | ip6_hop_by_hop_ext_t *ext_hdr = |
| 1041 | (ip6_hop_by_hop_ext_t *) data_this_buffer; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1042 | |
| 1043 | /* validate really icmp6 next */ |
AkshayaNadahalli | 1b56352 | 2017-01-23 22:05:35 +0530 | [diff] [blame] | 1044 | ASSERT ((ext_hdr->next_hdr == IP_PROTOCOL_ICMP6) |
| 1045 | || (ext_hdr->next_hdr == IP_PROTOCOL_UDP)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1046 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1047 | skip_bytes = 8 * (1 + ext_hdr->n_data_u64s); |
| 1048 | data_this_buffer = (void *) ((u8 *) data_this_buffer + skip_bytes); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1049 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1050 | payload_length_host_byte_order -= skip_bytes; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1051 | headers_size += skip_bytes; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1052 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1053 | |
John Lo | 3bc6bc2 | 2019-08-03 14:36:39 -0400 | [diff] [blame] | 1054 | if (p0) |
Srikanth A | 02833ff | 2019-10-02 17:48:58 -0700 | [diff] [blame] | 1055 | return ip_calculate_l4_checksum (vm, p0, sum0, |
| 1056 | payload_length_host_byte_order, |
| 1057 | (u8 *) ip0, headers_size, NULL); |
| 1058 | else |
| 1059 | return ip_calculate_l4_checksum (vm, 0, sum0, |
| 1060 | payload_length_host_byte_order, NULL, 0, |
| 1061 | data_this_buffer); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1062 | } |
| 1063 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1064 | u32 |
| 1065 | ip6_tcp_udp_icmp_validate_checksum (vlib_main_t * vm, vlib_buffer_t * p0) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1066 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1067 | ip6_header_t *ip0 = vlib_buffer_get_current (p0); |
| 1068 | udp_header_t *udp0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1069 | u16 sum16; |
| 1070 | int bogus_length; |
| 1071 | |
| 1072 | /* some icmp packets may come with a "router alert" hop-by-hop extension header (e.g., mldv2 packets) */ |
| 1073 | ASSERT (ip0->protocol == IP_PROTOCOL_TCP |
| 1074 | || ip0->protocol == IP_PROTOCOL_ICMP6 |
| 1075 | || ip0->protocol == IP_PROTOCOL_UDP |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1076 | || ip0->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1077 | |
| 1078 | udp0 = (void *) (ip0 + 1); |
| 1079 | if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0) |
| 1080 | { |
Damjan Marion | 213b5aa | 2017-07-13 21:19:27 +0200 | [diff] [blame] | 1081 | p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED |
| 1082 | | VNET_BUFFER_F_L4_CHECKSUM_CORRECT); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1083 | return p0->flags; |
| 1084 | } |
| 1085 | |
| 1086 | sum16 = ip6_tcp_udp_icmp_compute_checksum (vm, p0, ip0, &bogus_length); |
| 1087 | |
Damjan Marion | 213b5aa | 2017-07-13 21:19:27 +0200 | [diff] [blame] | 1088 | p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED |
| 1089 | | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1090 | |
| 1091 | return p0->flags; |
| 1092 | } |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 1093 | #endif |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1094 | |
AkshayaNadahalli | 0f438df | 2017-02-10 10:54:16 +0530 | [diff] [blame] | 1095 | /** |
| 1096 | * @brief returns number of links on which src is reachable. |
| 1097 | */ |
| 1098 | always_inline int |
| 1099 | ip6_urpf_loose_check (ip6_main_t * im, vlib_buffer_t * b, ip6_header_t * i) |
| 1100 | { |
| 1101 | const load_balance_t *lb0; |
| 1102 | index_t lbi; |
Florin Coras | f3a3bad | 2018-03-28 02:18:29 -0700 | [diff] [blame] | 1103 | u32 fib_index; |
AkshayaNadahalli | 0f438df | 2017-02-10 10:54:16 +0530 | [diff] [blame] | 1104 | |
Florin Coras | f3a3bad | 2018-03-28 02:18:29 -0700 | [diff] [blame] | 1105 | fib_index = vec_elt (im->fib_index_by_sw_if_index, |
| 1106 | vnet_buffer (b)->sw_if_index[VLIB_RX]); |
| 1107 | fib_index = |
| 1108 | (vnet_buffer (b)->sw_if_index[VLIB_TX] == (u32) ~ 0) ? |
| 1109 | fib_index : vnet_buffer (b)->sw_if_index[VLIB_TX]; |
AkshayaNadahalli | 0f438df | 2017-02-10 10:54:16 +0530 | [diff] [blame] | 1110 | |
Simon Zhang | e7eba48 | 2019-08-25 15:30:45 +0800 | [diff] [blame] | 1111 | lbi = ip6_fib_table_fwding_lookup (fib_index, &i->src_address); |
AkshayaNadahalli | 0f438df | 2017-02-10 10:54:16 +0530 | [diff] [blame] | 1112 | lb0 = load_balance_get (lbi); |
| 1113 | |
| 1114 | return (fib_urpf_check_size (lb0->lb_urpf)); |
| 1115 | } |
| 1116 | |
root | c9d1c5b | 2017-08-15 12:58:31 -0400 | [diff] [blame] | 1117 | always_inline u8 |
| 1118 | ip6_next_proto_is_tcp_udp (vlib_buffer_t * p0, ip6_header_t * ip0, |
| 1119 | u32 * udp_offset0) |
| 1120 | { |
| 1121 | u32 proto0; |
| 1122 | proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_UDP, udp_offset0); |
| 1123 | if (proto0 != IP_PROTOCOL_UDP) |
| 1124 | { |
| 1125 | proto0 = ip6_locate_header (p0, ip0, IP_PROTOCOL_TCP, udp_offset0); |
| 1126 | proto0 = (proto0 == IP_PROTOCOL_TCP) ? proto0 : 0; |
| 1127 | } |
| 1128 | return proto0; |
| 1129 | } |
| 1130 | |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1131 | /* *INDENT-OFF* */ |
| 1132 | VNET_FEATURE_ARC_INIT (ip6_local) = |
| 1133 | { |
| 1134 | .arc_name = "ip6-local", |
| 1135 | .start_nodes = VNET_FEATURES ("ip6-local"), |
| 1136 | }; |
| 1137 | /* *INDENT-ON* */ |
| 1138 | |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1139 | static_always_inline u8 |
| 1140 | ip6_tcp_udp_icmp_bad_length (vlib_main_t * vm, vlib_buffer_t * p0) |
| 1141 | { |
| 1142 | |
| 1143 | u16 payload_length_host_byte_order; |
| 1144 | u32 n_this_buffer, n_bytes_left; |
| 1145 | ip6_header_t *ip0 = vlib_buffer_get_current (p0); |
| 1146 | u32 headers_size = sizeof (ip0[0]); |
| 1147 | u8 *data_this_buffer; |
| 1148 | |
| 1149 | |
| 1150 | data_this_buffer = (u8 *) (ip0 + 1); |
| 1151 | |
| 1152 | ip6_hop_by_hop_ext_t *ext_hdr = (ip6_hop_by_hop_ext_t *) data_this_buffer; |
| 1153 | |
| 1154 | /* validate really icmp6 next */ |
| 1155 | |
| 1156 | if (!(ext_hdr->next_hdr == IP_PROTOCOL_ICMP6) |
| 1157 | || (ext_hdr->next_hdr == IP_PROTOCOL_UDP)) |
| 1158 | return 0; |
| 1159 | |
| 1160 | |
| 1161 | payload_length_host_byte_order = clib_net_to_host_u16 (ip0->payload_length); |
| 1162 | n_bytes_left = n_this_buffer = payload_length_host_byte_order; |
| 1163 | |
johny | a633a43 | 2019-12-06 13:58:35 +0100 | [diff] [blame] | 1164 | |
| 1165 | u32 n_ip_bytes_this_buffer = |
| 1166 | p0->current_length - (((u8 *) ip0 - p0->data) - p0->current_data); |
| 1167 | if (n_this_buffer + headers_size > n_ip_bytes_this_buffer) |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1168 | { |
johny | a633a43 | 2019-12-06 13:58:35 +0100 | [diff] [blame] | 1169 | n_this_buffer = p0->current_length > headers_size ? |
| 1170 | n_ip_bytes_this_buffer - headers_size : 0; |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1171 | } |
| 1172 | |
| 1173 | n_bytes_left -= n_this_buffer; |
| 1174 | n_bytes_left -= p0->total_length_not_including_first_buffer; |
| 1175 | |
| 1176 | if (n_bytes_left == 0) |
| 1177 | return 0; |
| 1178 | else |
| 1179 | return 1; |
| 1180 | } |
| 1181 | |
| 1182 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1183 | always_inline uword |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1184 | ip6_local_inline (vlib_main_t * vm, vlib_node_runtime_t * node, |
| 1185 | vlib_frame_t * frame, int head_of_feature_arc) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1186 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1187 | ip6_main_t *im = &ip6_main; |
| 1188 | ip_lookup_main_t *lm = &im->lookup_main; |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1189 | u32 *from, n_left_from; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1190 | vlib_node_runtime_t *error_node = |
| 1191 | vlib_node_get_runtime (vm, ip6_input_node.index); |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1192 | u8 arc_index = vnet_feat_arc_ip6_local.feature_arc_index; |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1193 | vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b; |
| 1194 | u16 nexts[VLIB_FRAME_SIZE], *next; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1195 | |
| 1196 | from = vlib_frame_vector_args (frame); |
| 1197 | n_left_from = frame->n_vectors; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1198 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1199 | if (node->flags & VLIB_NODE_FLAG_TRACE) |
| 1200 | ip6_forward_next_trace (vm, node, frame, VLIB_TX); |
| 1201 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1202 | vlib_get_buffers (vm, from, bufs, n_left_from); |
| 1203 | b = bufs; |
| 1204 | next = nexts; |
| 1205 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1206 | while (n_left_from > 2) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1207 | { |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1208 | /* Prefetch next iteration. */ |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1209 | if (n_left_from >= 6) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1210 | { |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1211 | vlib_prefetch_buffer_header (b[4], STORE); |
| 1212 | vlib_prefetch_buffer_header (b[5], STORE); |
| 1213 | vlib_prefetch_buffer_data (b[2], LOAD); |
| 1214 | vlib_prefetch_buffer_data (b[3], LOAD); |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1215 | } |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1216 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1217 | u8 error[2]; |
| 1218 | error[0] = IP6_ERROR_UNKNOWN_PROTOCOL; |
| 1219 | error[1] = IP6_ERROR_UNKNOWN_PROTOCOL; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1220 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1221 | ip6_header_t *ip[2]; |
| 1222 | ip[0] = vlib_buffer_get_current (b[0]); |
| 1223 | ip[1] = vlib_buffer_get_current (b[1]); |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1224 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1225 | if (head_of_feature_arc) |
| 1226 | { |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1227 | vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data; |
| 1228 | vnet_buffer (b[1])->l3_hdr_offset = b[1]->current_data; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1229 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1230 | u8 type[2]; |
| 1231 | type[0] = lm->builtin_protocol_by_ip_protocol[ip[0]->protocol]; |
| 1232 | type[1] = lm->builtin_protocol_by_ip_protocol[ip[1]->protocol]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1233 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1234 | u32 flags[2]; |
| 1235 | flags[0] = b[0]->flags; |
| 1236 | flags[1] = b[1]->flags; |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1237 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1238 | u32 good_l4_csum[2]; |
| 1239 | good_l4_csum[0] = |
| 1240 | flags[0] & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT | |
| 1241 | VNET_BUFFER_F_OFFLOAD_TCP_CKSUM | |
| 1242 | VNET_BUFFER_F_OFFLOAD_UDP_CKSUM); |
| 1243 | good_l4_csum[1] = |
| 1244 | flags[1] & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1245 | VNET_BUFFER_F_OFFLOAD_TCP_CKSUM | |
| 1246 | VNET_BUFFER_F_OFFLOAD_UDP_CKSUM); |
Filip Tehlar | b601f22 | 2017-01-02 10:22:56 +0100 | [diff] [blame] | 1247 | |
Damjan Marion | 34e823f | 2019-02-19 08:55:18 +0100 | [diff] [blame] | 1248 | u32 udp_offset[2] = { }; |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1249 | u8 is_tcp_udp[2]; |
| 1250 | is_tcp_udp[0] = |
| 1251 | ip6_next_proto_is_tcp_udp (b[0], ip[0], &udp_offset[0]); |
| 1252 | is_tcp_udp[1] = |
| 1253 | ip6_next_proto_is_tcp_udp (b[1], ip[1], &udp_offset[1]); |
| 1254 | i16 len_diff[2] = { 0 }; |
| 1255 | if (PREDICT_TRUE (is_tcp_udp[0])) |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 1256 | { |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1257 | udp_header_t *udp = |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1258 | (udp_header_t *) ((u8 *) ip[0] + udp_offset[0]); |
| 1259 | good_l4_csum[0] |= type[0] == IP_BUILTIN_PROTOCOL_UDP |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1260 | && udp->checksum == 0; |
| 1261 | /* optimistically verify UDP length. */ |
| 1262 | u16 ip_len, udp_len; |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1263 | ip_len = clib_net_to_host_u16 (ip[0]->payload_length); |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1264 | udp_len = clib_net_to_host_u16 (udp->length); |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1265 | len_diff[0] = ip_len - udp_len; |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 1266 | } |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1267 | if (PREDICT_TRUE (is_tcp_udp[1])) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1268 | { |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1269 | udp_header_t *udp = |
| 1270 | (udp_header_t *) ((u8 *) ip[1] + udp_offset[1]); |
| 1271 | good_l4_csum[1] |= type[1] == IP_BUILTIN_PROTOCOL_UDP |
| 1272 | && udp->checksum == 0; |
| 1273 | /* optimistically verify UDP length. */ |
| 1274 | u16 ip_len, udp_len; |
| 1275 | ip_len = clib_net_to_host_u16 (ip[1]->payload_length); |
| 1276 | udp_len = clib_net_to_host_u16 (udp->length); |
| 1277 | len_diff[1] = ip_len - udp_len; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1278 | } |
| 1279 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1280 | good_l4_csum[0] |= type[0] == IP_BUILTIN_PROTOCOL_UNKNOWN; |
| 1281 | good_l4_csum[1] |= type[1] == IP_BUILTIN_PROTOCOL_UNKNOWN; |
| 1282 | |
| 1283 | len_diff[0] = type[0] == IP_BUILTIN_PROTOCOL_UDP ? len_diff[0] : 0; |
| 1284 | len_diff[1] = type[1] == IP_BUILTIN_PROTOCOL_UDP ? len_diff[1] : 0; |
| 1285 | |
| 1286 | u8 need_csum[2]; |
| 1287 | need_csum[0] = type[0] != IP_BUILTIN_PROTOCOL_UNKNOWN |
| 1288 | && !good_l4_csum[0] |
| 1289 | && !(flags[0] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED); |
| 1290 | need_csum[1] = type[1] != IP_BUILTIN_PROTOCOL_UNKNOWN |
| 1291 | && !good_l4_csum[1] |
| 1292 | && !(flags[1] & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED); |
| 1293 | if (PREDICT_FALSE (need_csum[0])) |
| 1294 | { |
| 1295 | flags[0] = ip6_tcp_udp_icmp_validate_checksum (vm, b[0]); |
| 1296 | good_l4_csum[0] = flags[0] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT; |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1297 | error[0] = IP6_ERROR_UNKNOWN_PROTOCOL; |
| 1298 | } |
| 1299 | else |
| 1300 | { |
| 1301 | if (ip6_tcp_udp_icmp_bad_length (vm, b[0])) |
| 1302 | error[0] = IP6_ERROR_BAD_LENGTH; |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1303 | } |
| 1304 | if (PREDICT_FALSE (need_csum[1])) |
| 1305 | { |
| 1306 | flags[1] = ip6_tcp_udp_icmp_validate_checksum (vm, b[1]); |
| 1307 | good_l4_csum[1] = flags[1] & VNET_BUFFER_F_L4_CHECKSUM_CORRECT; |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1308 | error[1] = IP6_ERROR_UNKNOWN_PROTOCOL; |
| 1309 | } |
| 1310 | else |
| 1311 | { |
| 1312 | if (ip6_tcp_udp_icmp_bad_length (vm, b[1])) |
| 1313 | error[1] = IP6_ERROR_BAD_LENGTH; |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1314 | } |
| 1315 | |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1316 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1317 | error[0] = len_diff[0] < 0 ? IP6_ERROR_UDP_LENGTH : error[0]; |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1318 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1319 | error[1] = len_diff[1] < 0 ? IP6_ERROR_UDP_LENGTH : error[1]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1320 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1321 | STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_UDP == |
| 1322 | IP6_ERROR_UDP_CHECKSUM, |
| 1323 | "Wrong IP6 errors constants"); |
| 1324 | STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP == |
| 1325 | IP6_ERROR_ICMP_CHECKSUM, |
| 1326 | "Wrong IP6 errors constants"); |
| 1327 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1328 | error[0] = |
| 1329 | !good_l4_csum[0] ? IP6_ERROR_UDP_CHECKSUM + type[0] : error[0]; |
| 1330 | error[1] = |
| 1331 | !good_l4_csum[1] ? IP6_ERROR_UDP_CHECKSUM + type[1] : error[1]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1332 | |
| 1333 | /* Drop packets from unroutable hosts. */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1334 | /* If this is a neighbor solicitation (ICMP), skip source RPF check */ |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1335 | u8 unroutable[2]; |
| 1336 | unroutable[0] = error[0] == IP6_ERROR_UNKNOWN_PROTOCOL |
| 1337 | && type[0] != IP_BUILTIN_PROTOCOL_ICMP |
| 1338 | && !ip6_address_is_link_local_unicast (&ip[0]->src_address); |
| 1339 | unroutable[1] = error[1] == IP6_ERROR_UNKNOWN_PROTOCOL |
| 1340 | && type[1] != IP_BUILTIN_PROTOCOL_ICMP |
| 1341 | && !ip6_address_is_link_local_unicast (&ip[1]->src_address); |
| 1342 | if (PREDICT_FALSE (unroutable[0])) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1343 | { |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1344 | error[0] = |
| 1345 | !ip6_urpf_loose_check (im, b[0], |
| 1346 | ip[0]) ? IP6_ERROR_SRC_LOOKUP_MISS |
| 1347 | : error[0]; |
| 1348 | } |
| 1349 | if (PREDICT_FALSE (unroutable[1])) |
| 1350 | { |
| 1351 | error[1] = |
| 1352 | !ip6_urpf_loose_check (im, b[1], |
| 1353 | ip[1]) ? IP6_ERROR_SRC_LOOKUP_MISS |
| 1354 | : error[1]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1355 | } |
| 1356 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1357 | vnet_buffer (b[0])->ip.fib_index = |
| 1358 | vnet_buffer (b[0])->sw_if_index[VLIB_TX] != ~0 ? |
| 1359 | vnet_buffer (b[0])->sw_if_index[VLIB_TX] : |
| 1360 | vnet_buffer (b[0])->ip.fib_index; |
| 1361 | vnet_buffer (b[1])->ip.fib_index = |
| 1362 | vnet_buffer (b[1])->sw_if_index[VLIB_TX] != ~0 ? |
| 1363 | vnet_buffer (b[1])->sw_if_index[VLIB_TX] : |
| 1364 | vnet_buffer (b[1])->ip.fib_index; |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1365 | } /* head_of_feature_arc */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1366 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1367 | next[0] = lm->local_next_by_ip_protocol[ip[0]->protocol]; |
| 1368 | next[0] = |
| 1369 | error[0] != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[0]; |
| 1370 | next[1] = lm->local_next_by_ip_protocol[ip[1]->protocol]; |
| 1371 | next[1] = |
| 1372 | error[1] != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[1]; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1373 | |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1374 | b[0]->error = error_node->errors[0]; |
| 1375 | b[1]->error = error_node->errors[1]; |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1376 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1377 | if (head_of_feature_arc) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1378 | { |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1379 | u8 ip6_unknown[2]; |
| 1380 | ip6_unknown[0] = error[0] == (u8) IP6_ERROR_UNKNOWN_PROTOCOL; |
| 1381 | ip6_unknown[1] = error[1] == (u8) IP6_ERROR_UNKNOWN_PROTOCOL; |
| 1382 | if (PREDICT_TRUE (ip6_unknown[0])) |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 1383 | { |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1384 | u32 next32 = next[0]; |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1385 | vnet_feature_arc_start (arc_index, |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1386 | vnet_buffer (b[0])->sw_if_index |
| 1387 | [VLIB_RX], &next32, b[0]); |
| 1388 | next[0] = next32; |
| 1389 | } |
| 1390 | if (PREDICT_TRUE (ip6_unknown[1])) |
| 1391 | { |
| 1392 | u32 next32 = next[1]; |
| 1393 | vnet_feature_arc_start (arc_index, |
| 1394 | vnet_buffer (b[1])->sw_if_index |
| 1395 | [VLIB_RX], &next32, b[1]); |
| 1396 | next[1] = next32; |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 1397 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1398 | } |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1399 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1400 | /* next */ |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1401 | b += 2; |
| 1402 | next += 2; |
| 1403 | n_left_from -= 2; |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1404 | } |
Benoît Ganne | 7dcb80a | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1405 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1406 | while (n_left_from) |
| 1407 | { |
| 1408 | u8 error; |
| 1409 | error = IP6_ERROR_UNKNOWN_PROTOCOL; |
| 1410 | |
| 1411 | ip6_header_t *ip; |
| 1412 | ip = vlib_buffer_get_current (b[0]); |
| 1413 | |
| 1414 | if (head_of_feature_arc) |
| 1415 | { |
| 1416 | vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data; |
| 1417 | u8 type = lm->builtin_protocol_by_ip_protocol[ip->protocol]; |
| 1418 | |
| 1419 | u32 flags = b[0]->flags; |
| 1420 | u32 good_l4_csum = |
| 1421 | flags & (VNET_BUFFER_F_L4_CHECKSUM_CORRECT | |
| 1422 | VNET_BUFFER_F_OFFLOAD_TCP_CKSUM | |
| 1423 | VNET_BUFFER_F_OFFLOAD_UDP_CKSUM); |
| 1424 | |
| 1425 | u32 udp_offset; |
| 1426 | i16 len_diff = 0; |
| 1427 | u8 is_tcp_udp = ip6_next_proto_is_tcp_udp (b[0], ip, &udp_offset); |
| 1428 | if (PREDICT_TRUE (is_tcp_udp)) |
| 1429 | { |
| 1430 | udp_header_t *udp = (udp_header_t *) ((u8 *) ip + udp_offset); |
| 1431 | /* Don't verify UDP checksum for packets with explicit zero checksum. */ |
| 1432 | good_l4_csum |= type == IP_BUILTIN_PROTOCOL_UDP |
| 1433 | && udp->checksum == 0; |
| 1434 | /* optimistically verify UDP length. */ |
| 1435 | u16 ip_len, udp_len; |
| 1436 | ip_len = clib_net_to_host_u16 (ip->payload_length); |
| 1437 | udp_len = clib_net_to_host_u16 (udp->length); |
| 1438 | len_diff = ip_len - udp_len; |
| 1439 | } |
| 1440 | |
| 1441 | good_l4_csum |= type == IP_BUILTIN_PROTOCOL_UNKNOWN; |
| 1442 | len_diff = type == IP_BUILTIN_PROTOCOL_UDP ? len_diff : 0; |
| 1443 | |
| 1444 | u8 need_csum = type != IP_BUILTIN_PROTOCOL_UNKNOWN && !good_l4_csum |
| 1445 | && !(flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED); |
| 1446 | if (PREDICT_FALSE (need_csum)) |
| 1447 | { |
| 1448 | flags = ip6_tcp_udp_icmp_validate_checksum (vm, b[0]); |
| 1449 | good_l4_csum = flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT; |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1450 | error = IP6_ERROR_UNKNOWN_PROTOCOL; |
| 1451 | } |
| 1452 | else |
| 1453 | { |
| 1454 | if (ip6_tcp_udp_icmp_bad_length (vm, b[0])) |
| 1455 | error = IP6_ERROR_BAD_LENGTH; |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1456 | } |
| 1457 | |
johny | 17478e4 | 2019-10-11 18:28:51 +0200 | [diff] [blame] | 1458 | |
| 1459 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1460 | error = len_diff < 0 ? IP6_ERROR_UDP_LENGTH : error; |
| 1461 | |
| 1462 | STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_UDP == |
| 1463 | IP6_ERROR_UDP_CHECKSUM, |
| 1464 | "Wrong IP6 errors constants"); |
| 1465 | STATIC_ASSERT (IP6_ERROR_UDP_CHECKSUM + IP_BUILTIN_PROTOCOL_ICMP == |
| 1466 | IP6_ERROR_ICMP_CHECKSUM, |
| 1467 | "Wrong IP6 errors constants"); |
| 1468 | |
| 1469 | error = !good_l4_csum ? IP6_ERROR_UDP_CHECKSUM + type : error; |
| 1470 | |
| 1471 | /* Drop packets from unroutable hosts. */ |
| 1472 | /* If this is a neighbor solicitation (ICMP), skip source RPF check */ |
| 1473 | u8 unroutable = error == IP6_ERROR_UNKNOWN_PROTOCOL |
| 1474 | && type != IP_BUILTIN_PROTOCOL_ICMP |
| 1475 | && !ip6_address_is_link_local_unicast (&ip->src_address); |
| 1476 | if (PREDICT_FALSE (unroutable)) |
| 1477 | { |
| 1478 | error = |
| 1479 | !ip6_urpf_loose_check (im, b[0], |
| 1480 | ip) ? IP6_ERROR_SRC_LOOKUP_MISS : |
| 1481 | error; |
| 1482 | } |
| 1483 | |
| 1484 | vnet_buffer (b[0])->ip.fib_index = |
| 1485 | vnet_buffer (b[0])->sw_if_index[VLIB_TX] != ~0 ? |
| 1486 | vnet_buffer (b[0])->sw_if_index[VLIB_TX] : |
| 1487 | vnet_buffer (b[0])->ip.fib_index; |
| 1488 | } /* head_of_feature_arc */ |
| 1489 | |
| 1490 | next[0] = lm->local_next_by_ip_protocol[ip->protocol]; |
| 1491 | next[0] = |
| 1492 | error != IP6_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next[0]; |
| 1493 | |
| 1494 | b[0]->error = error_node->errors[0]; |
| 1495 | |
| 1496 | if (head_of_feature_arc) |
| 1497 | { |
| 1498 | if (PREDICT_TRUE (error == (u8) IP6_ERROR_UNKNOWN_PROTOCOL)) |
| 1499 | { |
| 1500 | u32 next32 = next[0]; |
| 1501 | vnet_feature_arc_start (arc_index, |
| 1502 | vnet_buffer (b[0])->sw_if_index |
| 1503 | [VLIB_RX], &next32, b[0]); |
| 1504 | next[0] = next32; |
| 1505 | } |
| 1506 | } |
| 1507 | |
| 1508 | /* next */ |
| 1509 | b += 1; |
| 1510 | next += 1; |
| 1511 | n_left_from -= 1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1512 | } |
| 1513 | |
Benoît Ganne | 26a1019 | 2019-02-14 15:32:45 +0100 | [diff] [blame] | 1514 | vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1515 | return frame->n_vectors; |
| 1516 | } |
| 1517 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 1518 | VLIB_NODE_FN (ip6_local_node) (vlib_main_t * vm, vlib_node_runtime_t * node, |
| 1519 | vlib_frame_t * frame) |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1520 | { |
| 1521 | return ip6_local_inline (vm, node, frame, 1 /* head of feature arc */ ); |
| 1522 | } |
| 1523 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1524 | /* *INDENT-OFF* */ |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 1525 | VLIB_REGISTER_NODE (ip6_local_node) = |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1526 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1527 | .name = "ip6-local", |
| 1528 | .vector_size = sizeof (u32), |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1529 | .format_trace = format_ip6_forward_next_trace, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1530 | .n_next_nodes = IP_LOCAL_N_NEXT, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1531 | .next_nodes = |
| 1532 | { |
Neale Ranns | d91c1db | 2017-07-31 02:30:50 -0700 | [diff] [blame] | 1533 | [IP_LOCAL_NEXT_DROP] = "ip6-drop", |
| 1534 | [IP_LOCAL_NEXT_PUNT] = "ip6-punt", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1535 | [IP_LOCAL_NEXT_UDP_LOOKUP] = "ip6-udp-lookup", |
| 1536 | [IP_LOCAL_NEXT_ICMP] = "ip6-icmp-input", |
Klement Sekera | 896c896 | 2019-06-24 11:52:49 +0000 | [diff] [blame] | 1537 | [IP_LOCAL_NEXT_REASSEMBLY] = "ip6-full-reassembly", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1538 | }, |
| 1539 | }; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1540 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1541 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 1542 | VLIB_NODE_FN (ip6_local_end_of_arc_node) (vlib_main_t * vm, |
| 1543 | vlib_node_runtime_t * node, |
| 1544 | vlib_frame_t * frame) |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1545 | { |
| 1546 | return ip6_local_inline (vm, node, frame, 0 /* head of feature arc */ ); |
| 1547 | } |
| 1548 | |
| 1549 | /* *INDENT-OFF* */ |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 1550 | VLIB_REGISTER_NODE (ip6_local_end_of_arc_node) = { |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1551 | .name = "ip6-local-end-of-arc", |
| 1552 | .vector_size = sizeof (u32), |
| 1553 | |
| 1554 | .format_trace = format_ip6_forward_next_trace, |
| 1555 | .sibling_of = "ip6-local", |
| 1556 | }; |
| 1557 | |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 1558 | VNET_FEATURE_INIT (ip6_local_end_of_arc, static) = { |
| 1559 | .arc_name = "ip6-local", |
| 1560 | .node_name = "ip6-local-end-of-arc", |
| 1561 | .runs_before = 0, /* not before any other features */ |
| 1562 | }; |
| 1563 | /* *INDENT-ON* */ |
| 1564 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 1565 | #ifdef CLIB_MARCH_VARIANT |
| 1566 | extern vlib_node_registration_t ip6_local_node; |
| 1567 | |
| 1568 | #else |
| 1569 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1570 | void |
| 1571 | ip6_register_protocol (u32 protocol, u32 node_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1572 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1573 | vlib_main_t *vm = vlib_get_main (); |
| 1574 | ip6_main_t *im = &ip6_main; |
| 1575 | ip_lookup_main_t *lm = &im->lookup_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1576 | |
| 1577 | ASSERT (protocol < ARRAY_LEN (lm->local_next_by_ip_protocol)); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1578 | lm->local_next_by_ip_protocol[protocol] = |
| 1579 | vlib_node_add_next (vm, ip6_local_node.index, node_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1580 | } |
| 1581 | |
Neale Ranns | b538dd8 | 2019-05-21 06:54:54 -0700 | [diff] [blame] | 1582 | void |
| 1583 | ip6_unregister_protocol (u32 protocol) |
| 1584 | { |
| 1585 | ip6_main_t *im = &ip6_main; |
| 1586 | ip_lookup_main_t *lm = &im->lookup_main; |
| 1587 | |
| 1588 | ASSERT (protocol < ARRAY_LEN (lm->local_next_by_ip_protocol)); |
| 1589 | lm->local_next_by_ip_protocol[protocol] = IP_LOCAL_NEXT_PUNT; |
| 1590 | } |
| 1591 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1592 | clib_error_t * |
John Lo | 8637634 | 2018-06-11 20:14:49 -0400 | [diff] [blame] | 1593 | ip6_probe_neighbor (vlib_main_t * vm, ip6_address_t * dst, u32 sw_if_index, |
| 1594 | u8 refresh) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1595 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1596 | vnet_main_t *vnm = vnet_get_main (); |
| 1597 | ip6_main_t *im = &ip6_main; |
| 1598 | icmp6_neighbor_solicitation_header_t *h; |
| 1599 | ip6_address_t *src; |
| 1600 | ip_interface_address_t *ia; |
| 1601 | ip_adjacency_t *adj; |
| 1602 | vnet_hw_interface_t *hi; |
| 1603 | vnet_sw_interface_t *si; |
| 1604 | vlib_buffer_t *b; |
Neale Ranns | 7a27274 | 2017-05-30 02:08:14 -0700 | [diff] [blame] | 1605 | adj_index_t ai; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1606 | u32 bi = 0; |
| 1607 | int bogus_length; |
| 1608 | |
| 1609 | si = vnet_get_sw_interface (vnm, sw_if_index); |
| 1610 | |
| 1611 | if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)) |
| 1612 | { |
| 1613 | return clib_error_return (0, "%U: interface %U down", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1614 | format_ip6_address, dst, |
| 1615 | format_vnet_sw_if_index_name, vnm, |
| 1616 | sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1617 | } |
| 1618 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1619 | src = |
| 1620 | ip6_interface_address_matching_destination (im, dst, sw_if_index, &ia); |
| 1621 | if (!src) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1622 | { |
| 1623 | vnm->api_errno = VNET_API_ERROR_NO_MATCHING_INTERFACE; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1624 | return clib_error_return |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1625 | (0, "no matching interface address for destination %U (interface %U)", |
| 1626 | format_ip6_address, dst, |
| 1627 | format_vnet_sw_if_index_name, vnm, sw_if_index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1628 | } |
| 1629 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1630 | h = |
| 1631 | vlib_packet_template_get_packet (vm, |
| 1632 | &im->discover_neighbor_packet_template, |
| 1633 | &bi); |
John Lo | 084606b | 2018-06-19 15:27:48 -0400 | [diff] [blame] | 1634 | if (!h) |
| 1635 | return clib_error_return (0, "ICMP6 NS packet allocation failed"); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1636 | |
| 1637 | hi = vnet_get_sup_hw_interface (vnm, sw_if_index); |
| 1638 | |
| 1639 | /* Destination address is a solicited node multicast address. We need to fill in |
| 1640 | the low 24 bits with low 24 bits of target's address. */ |
| 1641 | h->ip.dst_address.as_u8[13] = dst->as_u8[13]; |
| 1642 | h->ip.dst_address.as_u8[14] = dst->as_u8[14]; |
| 1643 | h->ip.dst_address.as_u8[15] = dst->as_u8[15]; |
| 1644 | |
| 1645 | h->ip.src_address = src[0]; |
| 1646 | h->neighbor.target_address = dst[0]; |
| 1647 | |
Pavel Kotucek | 5780898 | 2017-08-02 08:20:19 +0200 | [diff] [blame] | 1648 | if (PREDICT_FALSE (!hi->hw_address)) |
| 1649 | { |
| 1650 | return clib_error_return (0, "%U: interface %U do not support ip probe", |
| 1651 | format_ip6_address, dst, |
| 1652 | format_vnet_sw_if_index_name, vnm, |
| 1653 | sw_if_index); |
| 1654 | } |
| 1655 | |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 1656 | clib_memcpy_fast (h->link_layer_option.ethernet_address, hi->hw_address, |
| 1657 | vec_len (hi->hw_address)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1658 | |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1659 | h->neighbor.icmp.checksum = |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1660 | ip6_tcp_udp_icmp_compute_checksum (vm, 0, &h->ip, &bogus_length); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1661 | ASSERT (bogus_length == 0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1662 | |
| 1663 | b = vlib_get_buffer (vm, bi); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1664 | vnet_buffer (b)->sw_if_index[VLIB_RX] = |
| 1665 | vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1666 | |
| 1667 | /* Add encapsulation string for software interface (e.g. ethernet header). */ |
Neale Ranns | 7a27274 | 2017-05-30 02:08:14 -0700 | [diff] [blame] | 1668 | ip46_address_t nh = { |
| 1669 | .ip6 = *dst, |
| 1670 | }; |
| 1671 | |
| 1672 | ai = adj_nbr_add_or_lock (FIB_PROTOCOL_IP6, |
| 1673 | VNET_LINK_IP6, &nh, sw_if_index); |
| 1674 | adj = adj_get (ai); |
| 1675 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 1676 | /* Peer has been previously resolved, retrieve glean adj instead */ |
John Lo | 8637634 | 2018-06-11 20:14:49 -0400 | [diff] [blame] | 1677 | if (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE && refresh == 0) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 1678 | { |
| 1679 | adj_unlock (ai); |
Ole Troan | 6ee4051 | 2018-02-12 18:14:39 +0100 | [diff] [blame] | 1680 | ai = adj_glean_add_or_lock (FIB_PROTOCOL_IP6, |
| 1681 | VNET_LINK_IP6, sw_if_index, &nh); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 1682 | adj = adj_get (ai); |
| 1683 | } |
| 1684 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1685 | vnet_rewrite_one_header (adj[0], h, sizeof (ethernet_header_t)); |
| 1686 | vlib_buffer_advance (b, -adj->rewrite_header.data_bytes); |
| 1687 | |
| 1688 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1689 | vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index); |
| 1690 | u32 *to_next = vlib_frame_vector_args (f); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1691 | to_next[0] = bi; |
| 1692 | f->n_vectors = 1; |
| 1693 | vlib_put_frame_to_node (vm, hi->output_node_index, f); |
| 1694 | } |
| 1695 | |
Neale Ranns | 7a27274 | 2017-05-30 02:08:14 -0700 | [diff] [blame] | 1696 | adj_unlock (ai); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1697 | return /* no error */ 0; |
| 1698 | } |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 1699 | #endif |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1700 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1701 | typedef enum |
| 1702 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1703 | IP6_REWRITE_NEXT_DROP, |
Chris Luke | 816f3e1 | 2016-06-14 16:24:47 -0400 | [diff] [blame] | 1704 | IP6_REWRITE_NEXT_ICMP_ERROR, |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1705 | IP6_REWRITE_NEXT_FRAGMENT, |
| 1706 | IP6_REWRITE_N_NEXT /* Last */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1707 | } ip6_rewrite_next_t; |
| 1708 | |
Neale Ranns | 889fe94 | 2017-06-01 05:43:19 -0400 | [diff] [blame] | 1709 | /** |
| 1710 | * This bits of an IPv6 address to mask to construct a multicast |
| 1711 | * MAC address |
| 1712 | */ |
| 1713 | #define IP6_MCAST_ADDR_MASK 0xffffffff |
| 1714 | |
Ole Troan | da6e11b | 2018-05-23 11:21:42 +0200 | [diff] [blame] | 1715 | always_inline void |
| 1716 | ip6_mtu_check (vlib_buffer_t * b, u16 packet_bytes, |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1717 | u16 adj_packet_bytes, bool is_locally_generated, |
Ole Troan | eb284a1 | 2019-10-09 13:33:19 +0200 | [diff] [blame] | 1718 | u32 * next, u8 is_midchain, u32 * error) |
Ole Troan | da6e11b | 2018-05-23 11:21:42 +0200 | [diff] [blame] | 1719 | { |
| 1720 | if (adj_packet_bytes >= 1280 && packet_bytes > adj_packet_bytes) |
| 1721 | { |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1722 | if (is_locally_generated) |
| 1723 | { |
| 1724 | /* IP fragmentation */ |
Ole Troan | 282093f | 2018-09-19 12:38:51 +0200 | [diff] [blame] | 1725 | ip_frag_set_vnet_buffer (b, adj_packet_bytes, |
Ole Troan | eb284a1 | 2019-10-09 13:33:19 +0200 | [diff] [blame] | 1726 | (is_midchain ? |
| 1727 | IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN : |
| 1728 | IP_FRAG_NEXT_IP_REWRITE), 0); |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1729 | *next = IP6_REWRITE_NEXT_FRAGMENT; |
Ole Troan | 282093f | 2018-09-19 12:38:51 +0200 | [diff] [blame] | 1730 | *error = IP6_ERROR_MTU_EXCEEDED; |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1731 | } |
| 1732 | else |
| 1733 | { |
| 1734 | *error = IP6_ERROR_MTU_EXCEEDED; |
| 1735 | icmp6_error_set_vnet_buffer (b, ICMP6_packet_too_big, 0, |
| 1736 | adj_packet_bytes); |
| 1737 | *next = IP6_REWRITE_NEXT_ICMP_ERROR; |
| 1738 | } |
Ole Troan | da6e11b | 2018-05-23 11:21:42 +0200 | [diff] [blame] | 1739 | } |
| 1740 | } |
| 1741 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1742 | always_inline uword |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 1743 | ip6_rewrite_inline_with_gso (vlib_main_t * vm, |
| 1744 | vlib_node_runtime_t * node, |
| 1745 | vlib_frame_t * frame, |
Mohsin Kazmi | 3f5594d | 2019-12-03 18:56:26 +0100 | [diff] [blame] | 1746 | int do_counters, int is_midchain, int is_mcast) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1747 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1748 | ip_lookup_main_t *lm = &ip6_main.lookup_main; |
| 1749 | u32 *from = vlib_frame_vector_args (frame); |
| 1750 | u32 n_left_from, n_left_to_next, *to_next, next_index; |
| 1751 | vlib_node_runtime_t *error_node = |
| 1752 | vlib_node_get_runtime (vm, ip6_input_node.index); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1753 | |
| 1754 | n_left_from = frame->n_vectors; |
| 1755 | next_index = node->cached_next_index; |
Damjan Marion | 067cd62 | 2018-07-11 12:47:43 +0200 | [diff] [blame] | 1756 | u32 thread_index = vm->thread_index; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1757 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1758 | while (n_left_from > 0) |
| 1759 | { |
| 1760 | vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); |
| 1761 | |
| 1762 | while (n_left_from >= 4 && n_left_to_next >= 2) |
| 1763 | { |
Neale Ranns | 960eeea | 2019-12-02 23:28:50 +0000 | [diff] [blame] | 1764 | const ip_adjacency_t *adj0, *adj1; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1765 | vlib_buffer_t *p0, *p1; |
| 1766 | ip6_header_t *ip0, *ip1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1767 | u32 pi0, rw_len0, next0, error0, adj_index0; |
| 1768 | u32 pi1, rw_len1, next1, error1, adj_index1; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1769 | u32 tx_sw_if_index0, tx_sw_if_index1; |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1770 | bool is_locally_originated0, is_locally_originated1; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1771 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1772 | /* Prefetch next iteration. */ |
| 1773 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1774 | vlib_buffer_t *p2, *p3; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1775 | |
| 1776 | p2 = vlib_get_buffer (vm, from[2]); |
| 1777 | p3 = vlib_get_buffer (vm, from[3]); |
| 1778 | |
| 1779 | vlib_prefetch_buffer_header (p2, LOAD); |
| 1780 | vlib_prefetch_buffer_header (p3, LOAD); |
| 1781 | |
| 1782 | CLIB_PREFETCH (p2->pre_data, 32, STORE); |
| 1783 | CLIB_PREFETCH (p3->pre_data, 32, STORE); |
| 1784 | |
| 1785 | CLIB_PREFETCH (p2->data, sizeof (ip0[0]), STORE); |
| 1786 | CLIB_PREFETCH (p3->data, sizeof (ip0[0]), STORE); |
| 1787 | } |
| 1788 | |
| 1789 | pi0 = to_next[0] = from[0]; |
| 1790 | pi1 = to_next[1] = from[1]; |
| 1791 | |
| 1792 | from += 2; |
| 1793 | n_left_from -= 2; |
| 1794 | to_next += 2; |
| 1795 | n_left_to_next -= 2; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 1796 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1797 | p0 = vlib_get_buffer (vm, pi0); |
| 1798 | p1 = vlib_get_buffer (vm, pi1); |
| 1799 | |
Neale Ranns | f06aea5 | 2016-11-29 06:51:37 -0800 | [diff] [blame] | 1800 | adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX]; |
| 1801 | adj_index1 = vnet_buffer (p1)->ip.adj_index[VLIB_TX]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1802 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1803 | ip0 = vlib_buffer_get_current (p0); |
| 1804 | ip1 = vlib_buffer_get_current (p1); |
| 1805 | |
| 1806 | error0 = error1 = IP6_ERROR_NONE; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1807 | next0 = next1 = IP6_REWRITE_NEXT_DROP; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1808 | |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1809 | is_locally_originated0 = |
| 1810 | p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED; |
| 1811 | if (PREDICT_TRUE (!is_locally_originated0)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1812 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1813 | i32 hop_limit0 = ip0->hop_limit; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1814 | |
| 1815 | /* Input node should have reject packets with hop limit 0. */ |
| 1816 | ASSERT (ip0->hop_limit > 0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1817 | |
| 1818 | hop_limit0 -= 1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1819 | |
| 1820 | ip0->hop_limit = hop_limit0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1821 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1822 | /* |
| 1823 | * If the hop count drops below 1 when forwarding, generate |
| 1824 | * an ICMP response. |
| 1825 | */ |
| 1826 | if (PREDICT_FALSE (hop_limit0 <= 0)) |
| 1827 | { |
| 1828 | error0 = IP6_ERROR_TIME_EXPIRED; |
| 1829 | next0 = IP6_REWRITE_NEXT_ICMP_ERROR; |
| 1830 | vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0; |
| 1831 | icmp6_error_set_vnet_buffer (p0, ICMP6_time_exceeded, |
| 1832 | ICMP6_time_exceeded_ttl_exceeded_in_transit, |
| 1833 | 0); |
| 1834 | } |
Neale Ranns | f06aea5 | 2016-11-29 06:51:37 -0800 | [diff] [blame] | 1835 | } |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1836 | else |
| 1837 | { |
Damjan Marion | 213b5aa | 2017-07-13 21:19:27 +0200 | [diff] [blame] | 1838 | p0->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1839 | } |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 1840 | is_locally_originated1 = |
| 1841 | p1->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED; |
| 1842 | if (PREDICT_TRUE (!is_locally_originated1)) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1843 | { |
Neale Ranns | f06aea5 | 2016-11-29 06:51:37 -0800 | [diff] [blame] | 1844 | i32 hop_limit1 = ip1->hop_limit; |
| 1845 | |
| 1846 | /* Input node should have reject packets with hop limit 0. */ |
| 1847 | ASSERT (ip1->hop_limit > 0); |
| 1848 | |
| 1849 | hop_limit1 -= 1; |
| 1850 | |
| 1851 | ip1->hop_limit = hop_limit1; |
| 1852 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1853 | /* |
| 1854 | * If the hop count drops below 1 when forwarding, generate |
| 1855 | * an ICMP response. |
| 1856 | */ |
| 1857 | if (PREDICT_FALSE (hop_limit1 <= 0)) |
| 1858 | { |
| 1859 | error1 = IP6_ERROR_TIME_EXPIRED; |
| 1860 | next1 = IP6_REWRITE_NEXT_ICMP_ERROR; |
| 1861 | vnet_buffer (p1)->sw_if_index[VLIB_TX] = (u32) ~ 0; |
| 1862 | icmp6_error_set_vnet_buffer (p1, ICMP6_time_exceeded, |
| 1863 | ICMP6_time_exceeded_ttl_exceeded_in_transit, |
| 1864 | 0); |
| 1865 | } |
| 1866 | } |
| 1867 | else |
| 1868 | { |
Damjan Marion | 213b5aa | 2017-07-13 21:19:27 +0200 | [diff] [blame] | 1869 | p1->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1870 | } |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 1871 | adj0 = adj_get (adj_index0); |
| 1872 | adj1 = adj_get (adj_index1); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1873 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1874 | rw_len0 = adj0[0].rewrite_header.data_bytes; |
| 1875 | rw_len1 = adj1[0].rewrite_header.data_bytes; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1876 | vnet_buffer (p0)->ip.save_rewrite_length = rw_len0; |
| 1877 | vnet_buffer (p1)->ip.save_rewrite_length = rw_len1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1878 | |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 1879 | if (do_counters) |
| 1880 | { |
| 1881 | vlib_increment_combined_counter |
| 1882 | (&adjacency_counters, |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 1883 | thread_index, adj_index0, 1, |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 1884 | vlib_buffer_length_in_chain (vm, p0) + rw_len0); |
| 1885 | vlib_increment_combined_counter |
| 1886 | (&adjacency_counters, |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 1887 | thread_index, adj_index1, 1, |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 1888 | vlib_buffer_length_in_chain (vm, p1) + rw_len1); |
| 1889 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1890 | |
| 1891 | /* Check MTU of outgoing interface. */ |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 1892 | u16 ip0_len = |
| 1893 | clib_net_to_host_u16 (ip0->payload_length) + |
| 1894 | sizeof (ip6_header_t); |
| 1895 | u16 ip1_len = |
| 1896 | clib_net_to_host_u16 (ip1->payload_length) + |
| 1897 | sizeof (ip6_header_t); |
Mohsin Kazmi | 3f5594d | 2019-12-03 18:56:26 +0100 | [diff] [blame] | 1898 | if (p0->flags & VNET_BUFFER_F_GSO) |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 1899 | ip0_len = gso_mtu_sz (p0); |
Mohsin Kazmi | 3f5594d | 2019-12-03 18:56:26 +0100 | [diff] [blame] | 1900 | if (p1->flags & VNET_BUFFER_F_GSO) |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 1901 | ip1_len = gso_mtu_sz (p1); |
| 1902 | |
| 1903 | |
| 1904 | |
| 1905 | ip6_mtu_check (p0, ip0_len, |
Ole Troan | da6e11b | 2018-05-23 11:21:42 +0200 | [diff] [blame] | 1906 | adj0[0].rewrite_header.max_l3_packet_bytes, |
Ole Troan | eb284a1 | 2019-10-09 13:33:19 +0200 | [diff] [blame] | 1907 | is_locally_originated0, &next0, is_midchain, |
| 1908 | &error0); |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 1909 | ip6_mtu_check (p1, ip1_len, |
Ole Troan | da6e11b | 2018-05-23 11:21:42 +0200 | [diff] [blame] | 1910 | adj1[0].rewrite_header.max_l3_packet_bytes, |
Ole Troan | eb284a1 | 2019-10-09 13:33:19 +0200 | [diff] [blame] | 1911 | is_locally_originated1, &next1, is_midchain, |
| 1912 | &error1); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1913 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1914 | /* Don't adjust the buffer for hop count issue; icmp-error node |
Jim Thompson | f324dec | 2019-04-08 03:22:21 -0500 | [diff] [blame] | 1915 | * wants to see the IP header */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1916 | if (PREDICT_TRUE (error0 == IP6_ERROR_NONE)) |
| 1917 | { |
| 1918 | p0->current_data -= rw_len0; |
| 1919 | p0->current_length += rw_len0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1920 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1921 | tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index; |
| 1922 | vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0; |
| 1923 | next0 = adj0[0].rewrite_header.next_index; |
Dave Barach | 5331c72 | 2016-08-17 11:54:30 -0400 | [diff] [blame] | 1924 | |
Neale Ranns | b069a69 | 2017-03-15 12:34:25 -0400 | [diff] [blame] | 1925 | if (PREDICT_FALSE |
| 1926 | (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES)) |
| 1927 | vnet_feature_arc_start (lm->output_feature_arc_index, |
| 1928 | tx_sw_if_index0, &next0, p0); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1929 | } |
Kingwel Xie | cb36a1d | 2019-03-20 03:45:47 -0400 | [diff] [blame] | 1930 | else |
| 1931 | { |
| 1932 | p0->error = error_node->errors[error0]; |
| 1933 | } |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1934 | if (PREDICT_TRUE (error1 == IP6_ERROR_NONE)) |
| 1935 | { |
| 1936 | p1->current_data -= rw_len1; |
| 1937 | p1->current_length += rw_len1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1938 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1939 | tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index; |
| 1940 | vnet_buffer (p1)->sw_if_index[VLIB_TX] = tx_sw_if_index1; |
| 1941 | next1 = adj1[0].rewrite_header.next_index; |
Dave Barach | 5331c72 | 2016-08-17 11:54:30 -0400 | [diff] [blame] | 1942 | |
Neale Ranns | b069a69 | 2017-03-15 12:34:25 -0400 | [diff] [blame] | 1943 | if (PREDICT_FALSE |
| 1944 | (adj1[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES)) |
| 1945 | vnet_feature_arc_start (lm->output_feature_arc_index, |
| 1946 | tx_sw_if_index1, &next1, p1); |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 1947 | } |
Kingwel Xie | cb36a1d | 2019-03-20 03:45:47 -0400 | [diff] [blame] | 1948 | else |
| 1949 | { |
| 1950 | p1->error = error_node->errors[error1]; |
| 1951 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1952 | |
Neale Ranns | 25edf14 | 2019-03-22 08:12:48 +0000 | [diff] [blame] | 1953 | if (is_midchain) |
| 1954 | { |
| 1955 | /* before we paint on the next header, update the L4 |
| 1956 | * checksums if required, since there's no offload on a tunnel */ |
| 1957 | calc_checksums (vm, p0); |
| 1958 | calc_checksums (vm, p1); |
| 1959 | } |
| 1960 | |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 1961 | /* Guess we are only writing on simple Ethernet header. */ |
| 1962 | vnet_rewrite_two_headers (adj0[0], adj1[0], |
| 1963 | ip0, ip1, sizeof (ethernet_header_t)); |
| 1964 | |
| 1965 | if (is_midchain) |
| 1966 | { |
Neale Ranns | 25edf14 | 2019-03-22 08:12:48 +0000 | [diff] [blame] | 1967 | if (adj0->sub_type.midchain.fixup_func) |
| 1968 | adj0->sub_type.midchain.fixup_func |
| 1969 | (vm, adj0, p0, adj0->sub_type.midchain.fixup_data); |
| 1970 | if (adj1->sub_type.midchain.fixup_func) |
| 1971 | adj1->sub_type.midchain.fixup_func |
| 1972 | (vm, adj1, p1, adj1->sub_type.midchain.fixup_data); |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 1973 | } |
| 1974 | if (is_mcast) |
| 1975 | { |
| 1976 | /* |
| 1977 | * copy bytes from the IP address into the MAC rewrite |
| 1978 | */ |
Neale Ranns | 889fe94 | 2017-06-01 05:43:19 -0400 | [diff] [blame] | 1979 | vnet_ip_mcast_fixup_header (IP6_MCAST_ADDR_MASK, |
| 1980 | adj0-> |
| 1981 | rewrite_header.dst_mcast_offset, |
| 1982 | &ip0->dst_address.as_u32[3], |
| 1983 | (u8 *) ip0); |
| 1984 | vnet_ip_mcast_fixup_header (IP6_MCAST_ADDR_MASK, |
| 1985 | adj1-> |
| 1986 | rewrite_header.dst_mcast_offset, |
| 1987 | &ip1->dst_address.as_u32[3], |
| 1988 | (u8 *) ip1); |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 1989 | } |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 1990 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1991 | vlib_validate_buffer_enqueue_x2 (vm, node, next_index, |
| 1992 | to_next, n_left_to_next, |
| 1993 | pi0, pi1, next0, next1); |
| 1994 | } |
| 1995 | |
| 1996 | while (n_left_from > 0 && n_left_to_next > 0) |
| 1997 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 1998 | ip_adjacency_t *adj0; |
| 1999 | vlib_buffer_t *p0; |
| 2000 | ip6_header_t *ip0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2001 | u32 pi0, rw_len0; |
| 2002 | u32 adj_index0, next0, error0; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2003 | u32 tx_sw_if_index0; |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 2004 | bool is_locally_originated0; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2005 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2006 | pi0 = to_next[0] = from[0]; |
| 2007 | |
| 2008 | p0 = vlib_get_buffer (vm, pi0); |
| 2009 | |
Neale Ranns | f06aea5 | 2016-11-29 06:51:37 -0800 | [diff] [blame] | 2010 | adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX]; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2011 | |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 2012 | adj0 = adj_get (adj_index0); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2013 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2014 | ip0 = vlib_buffer_get_current (p0); |
| 2015 | |
| 2016 | error0 = IP6_ERROR_NONE; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2017 | next0 = IP6_REWRITE_NEXT_DROP; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2018 | |
| 2019 | /* Check hop limit */ |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 2020 | is_locally_originated0 = |
| 2021 | p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED; |
| 2022 | if (PREDICT_TRUE (!is_locally_originated0)) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2023 | { |
| 2024 | i32 hop_limit0 = ip0->hop_limit; |
| 2025 | |
| 2026 | ASSERT (ip0->hop_limit > 0); |
| 2027 | |
| 2028 | hop_limit0 -= 1; |
| 2029 | |
| 2030 | ip0->hop_limit = hop_limit0; |
| 2031 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2032 | if (PREDICT_FALSE (hop_limit0 <= 0)) |
| 2033 | { |
| 2034 | /* |
| 2035 | * If the hop count drops below 1 when forwarding, generate |
| 2036 | * an ICMP response. |
| 2037 | */ |
| 2038 | error0 = IP6_ERROR_TIME_EXPIRED; |
| 2039 | next0 = IP6_REWRITE_NEXT_ICMP_ERROR; |
| 2040 | vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0; |
| 2041 | icmp6_error_set_vnet_buffer (p0, ICMP6_time_exceeded, |
| 2042 | ICMP6_time_exceeded_ttl_exceeded_in_transit, |
| 2043 | 0); |
| 2044 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2045 | } |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2046 | else |
| 2047 | { |
Damjan Marion | 213b5aa | 2017-07-13 21:19:27 +0200 | [diff] [blame] | 2048 | p0->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2049 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2050 | |
Neale Ranns | 25edf14 | 2019-03-22 08:12:48 +0000 | [diff] [blame] | 2051 | if (is_midchain) |
| 2052 | { |
| 2053 | calc_checksums (vm, p0); |
| 2054 | } |
| 2055 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2056 | /* Guess we are only writing on simple Ethernet header. */ |
| 2057 | vnet_rewrite_one_header (adj0[0], ip0, sizeof (ethernet_header_t)); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2058 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2059 | /* Update packet buffer attributes/set output interface. */ |
| 2060 | rw_len0 = adj0[0].rewrite_header.data_bytes; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2061 | vnet_buffer (p0)->ip.save_rewrite_length = rw_len0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2062 | |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 2063 | if (do_counters) |
| 2064 | { |
| 2065 | vlib_increment_combined_counter |
| 2066 | (&adjacency_counters, |
Damjan Marion | 586afd7 | 2017-04-05 19:18:20 +0200 | [diff] [blame] | 2067 | thread_index, adj_index0, 1, |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 2068 | vlib_buffer_length_in_chain (vm, p0) + rw_len0); |
| 2069 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2070 | |
| 2071 | /* Check MTU of outgoing interface. */ |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 2072 | u16 ip0_len = |
| 2073 | clib_net_to_host_u16 (ip0->payload_length) + |
| 2074 | sizeof (ip6_header_t); |
Mohsin Kazmi | 3f5594d | 2019-12-03 18:56:26 +0100 | [diff] [blame] | 2075 | if (p0->flags & VNET_BUFFER_F_GSO) |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 2076 | ip0_len = gso_mtu_sz (p0); |
| 2077 | |
| 2078 | ip6_mtu_check (p0, ip0_len, |
Ole Troan | da6e11b | 2018-05-23 11:21:42 +0200 | [diff] [blame] | 2079 | adj0[0].rewrite_header.max_l3_packet_bytes, |
Ole Troan | eb284a1 | 2019-10-09 13:33:19 +0200 | [diff] [blame] | 2080 | is_locally_originated0, &next0, is_midchain, |
| 2081 | &error0); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2082 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2083 | /* Don't adjust the buffer for hop count issue; icmp-error node |
Ole Troan | da6e11b | 2018-05-23 11:21:42 +0200 | [diff] [blame] | 2084 | * wants to see the IP header */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2085 | if (PREDICT_TRUE (error0 == IP6_ERROR_NONE)) |
| 2086 | { |
Chris Luke | 816f3e1 | 2016-06-14 16:24:47 -0400 | [diff] [blame] | 2087 | p0->current_data -= rw_len0; |
| 2088 | p0->current_length += rw_len0; |
| 2089 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2090 | tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index; |
Dave Barach | 5331c72 | 2016-08-17 11:54:30 -0400 | [diff] [blame] | 2091 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2092 | vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0; |
| 2093 | next0 = adj0[0].rewrite_header.next_index; |
Dave Barach | 5331c72 | 2016-08-17 11:54:30 -0400 | [diff] [blame] | 2094 | |
Neale Ranns | b069a69 | 2017-03-15 12:34:25 -0400 | [diff] [blame] | 2095 | if (PREDICT_FALSE |
| 2096 | (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES)) |
| 2097 | vnet_feature_arc_start (lm->output_feature_arc_index, |
| 2098 | tx_sw_if_index0, &next0, p0); |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 2099 | } |
Kingwel Xie | cb36a1d | 2019-03-20 03:45:47 -0400 | [diff] [blame] | 2100 | else |
| 2101 | { |
| 2102 | p0->error = error_node->errors[error0]; |
| 2103 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2104 | |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 2105 | if (is_midchain) |
| 2106 | { |
Neale Ranns | 25edf14 | 2019-03-22 08:12:48 +0000 | [diff] [blame] | 2107 | if (adj0->sub_type.midchain.fixup_func) |
| 2108 | adj0->sub_type.midchain.fixup_func |
| 2109 | (vm, adj0, p0, adj0->sub_type.midchain.fixup_data); |
Damjan Marion | fe7d4a2 | 2018-04-13 19:43:39 +0200 | [diff] [blame] | 2110 | } |
| 2111 | if (is_mcast) |
| 2112 | { |
Neale Ranns | 889fe94 | 2017-06-01 05:43:19 -0400 | [diff] [blame] | 2113 | vnet_ip_mcast_fixup_header (IP6_MCAST_ADDR_MASK, |
| 2114 | adj0-> |
| 2115 | rewrite_header.dst_mcast_offset, |
| 2116 | &ip0->dst_address.as_u32[3], |
| 2117 | (u8 *) ip0); |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2118 | } |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 2119 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2120 | from += 1; |
| 2121 | n_left_from -= 1; |
| 2122 | to_next += 1; |
| 2123 | n_left_to_next -= 1; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2124 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2125 | vlib_validate_buffer_enqueue_x1 (vm, node, next_index, |
| 2126 | to_next, n_left_to_next, |
| 2127 | pi0, next0); |
| 2128 | } |
| 2129 | |
| 2130 | vlib_put_next_frame (vm, node, next_index, n_left_to_next); |
| 2131 | } |
| 2132 | |
| 2133 | /* Need to do trace after rewrites to pick up new packet data. */ |
| 2134 | if (node->flags & VLIB_NODE_FLAG_TRACE) |
Neale Ranns | f06aea5 | 2016-11-29 06:51:37 -0800 | [diff] [blame] | 2135 | ip6_forward_next_trace (vm, node, frame, VLIB_TX); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2136 | |
| 2137 | return frame->n_vectors; |
| 2138 | } |
| 2139 | |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 2140 | always_inline uword |
| 2141 | ip6_rewrite_inline (vlib_main_t * vm, |
| 2142 | vlib_node_runtime_t * node, |
| 2143 | vlib_frame_t * frame, |
| 2144 | int do_counters, int is_midchain, int is_mcast) |
| 2145 | { |
Mohsin Kazmi | 3f5594d | 2019-12-03 18:56:26 +0100 | [diff] [blame] | 2146 | return ip6_rewrite_inline_with_gso (vm, node, frame, do_counters, |
| 2147 | is_midchain, is_mcast); |
Andrew Yourtchenko | 6a7cff7 | 2018-10-12 16:09:22 +0200 | [diff] [blame] | 2148 | } |
| 2149 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2150 | VLIB_NODE_FN (ip6_rewrite_node) (vlib_main_t * vm, |
| 2151 | vlib_node_runtime_t * node, |
| 2152 | vlib_frame_t * frame) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2153 | { |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 2154 | if (adj_are_counters_enabled ()) |
| 2155 | return ip6_rewrite_inline (vm, node, frame, 1, 0, 0); |
| 2156 | else |
| 2157 | return ip6_rewrite_inline (vm, node, frame, 0, 0, 0); |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2158 | } |
| 2159 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2160 | VLIB_NODE_FN (ip6_rewrite_bcast_node) (vlib_main_t * vm, |
| 2161 | vlib_node_runtime_t * node, |
| 2162 | vlib_frame_t * frame) |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 2163 | { |
| 2164 | if (adj_are_counters_enabled ()) |
| 2165 | return ip6_rewrite_inline (vm, node, frame, 1, 0, 0); |
| 2166 | else |
| 2167 | return ip6_rewrite_inline (vm, node, frame, 0, 0, 0); |
| 2168 | } |
| 2169 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2170 | VLIB_NODE_FN (ip6_rewrite_mcast_node) (vlib_main_t * vm, |
| 2171 | vlib_node_runtime_t * node, |
| 2172 | vlib_frame_t * frame) |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2173 | { |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 2174 | if (adj_are_counters_enabled ()) |
| 2175 | return ip6_rewrite_inline (vm, node, frame, 1, 0, 1); |
| 2176 | else |
| 2177 | return ip6_rewrite_inline (vm, node, frame, 0, 0, 1); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2178 | } |
| 2179 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2180 | VLIB_NODE_FN (ip6_midchain_node) (vlib_main_t * vm, |
| 2181 | vlib_node_runtime_t * node, |
| 2182 | vlib_frame_t * frame) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 2183 | { |
Neale Ranns | 9c6a613 | 2017-02-21 05:33:14 -0800 | [diff] [blame] | 2184 | if (adj_are_counters_enabled ()) |
| 2185 | return ip6_rewrite_inline (vm, node, frame, 1, 1, 0); |
| 2186 | else |
| 2187 | return ip6_rewrite_inline (vm, node, frame, 0, 1, 0); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 2188 | } |
| 2189 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2190 | VLIB_NODE_FN (ip6_mcast_midchain_node) (vlib_main_t * vm, |
| 2191 | vlib_node_runtime_t * node, |
| 2192 | vlib_frame_t * frame) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 2193 | { |
| 2194 | if (adj_are_counters_enabled ()) |
| 2195 | return ip6_rewrite_inline (vm, node, frame, 1, 1, 1); |
| 2196 | else |
Neale Ranns | 9f171f5 | 2017-04-11 08:56:53 -0700 | [diff] [blame] | 2197 | return ip6_rewrite_inline (vm, node, frame, 0, 1, 1); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 2198 | } |
| 2199 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2200 | /* *INDENT-OFF* */ |
| 2201 | VLIB_REGISTER_NODE (ip6_midchain_node) = |
| 2202 | { |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 2203 | .name = "ip6-midchain", |
| 2204 | .vector_size = sizeof (u32), |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 2205 | .format_trace = format_ip6_forward_next_trace, |
Neale Ranns | 5e575b1 | 2016-10-03 09:40:25 +0100 | [diff] [blame] | 2206 | .sibling_of = "ip6-rewrite", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2207 | }; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 2208 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2209 | VLIB_REGISTER_NODE (ip6_rewrite_node) = |
| 2210 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2211 | .name = "ip6-rewrite", |
| 2212 | .vector_size = sizeof (u32), |
Pierre Pfister | a38c3df | 2016-06-13 10:28:09 +0100 | [diff] [blame] | 2213 | .format_trace = format_ip6_rewrite_trace, |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 2214 | .n_next_nodes = IP6_REWRITE_N_NEXT, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2215 | .next_nodes = |
| 2216 | { |
Vijayabhaskar Katamreddy | ce07412 | 2017-11-15 13:50:26 -0800 | [diff] [blame] | 2217 | [IP6_REWRITE_NEXT_DROP] = "ip6-drop", |
Chris Luke | 816f3e1 | 2016-06-14 16:24:47 -0400 | [diff] [blame] | 2218 | [IP6_REWRITE_NEXT_ICMP_ERROR] = "ip6-icmp-error", |
Ole Troan | 313f7e2 | 2018-04-10 16:02:51 +0200 | [diff] [blame] | 2219 | [IP6_REWRITE_NEXT_FRAGMENT] = "ip6-frag", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2220 | }, |
| 2221 | }; |
| 2222 | |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 2223 | VLIB_REGISTER_NODE (ip6_rewrite_bcast_node) = { |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 2224 | .name = "ip6-rewrite-bcast", |
| 2225 | .vector_size = sizeof (u32), |
| 2226 | |
| 2227 | .format_trace = format_ip6_rewrite_trace, |
| 2228 | .sibling_of = "ip6-rewrite", |
| 2229 | }; |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 2230 | |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2231 | VLIB_REGISTER_NODE (ip6_rewrite_mcast_node) = |
| 2232 | { |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2233 | .name = "ip6-rewrite-mcast", |
| 2234 | .vector_size = sizeof (u32), |
| 2235 | .format_trace = format_ip6_rewrite_trace, |
| 2236 | .sibling_of = "ip6-rewrite", |
| 2237 | }; |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2238 | |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2239 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2240 | VLIB_REGISTER_NODE (ip6_mcast_midchain_node) = |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 2241 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 2242 | .name = "ip6-mcast-midchain", |
| 2243 | .vector_size = sizeof (u32), |
| 2244 | .format_trace = format_ip6_rewrite_trace, |
| 2245 | .sibling_of = "ip6-rewrite", |
| 2246 | }; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 2247 | |
Neale Ranns | 1855b8e | 2018-07-11 10:31:26 -0700 | [diff] [blame] | 2248 | /* *INDENT-ON* */ |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 2249 | |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2250 | /* |
| 2251 | * Hop-by-Hop handling |
| 2252 | */ |
Benoît Ganne | 47727c0 | 2019-02-12 13:35:08 +0100 | [diff] [blame] | 2253 | #ifndef CLIB_MARCH_VARIANT |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2254 | ip6_hop_by_hop_main_t ip6_hop_by_hop_main; |
Benoît Ganne | 47727c0 | 2019-02-12 13:35:08 +0100 | [diff] [blame] | 2255 | #endif /* CLIB_MARCH_VARIANT */ |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2256 | |
| 2257 | #define foreach_ip6_hop_by_hop_error \ |
| 2258 | _(PROCESSED, "pkts with ip6 hop-by-hop options") \ |
| 2259 | _(FORMAT, "incorrectly formatted hop-by-hop options") \ |
| 2260 | _(UNKNOWN_OPTION, "unknown ip6 hop-by-hop options") |
| 2261 | |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2262 | /* *INDENT-OFF* */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2263 | typedef enum |
| 2264 | { |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2265 | #define _(sym,str) IP6_HOP_BY_HOP_ERROR_##sym, |
| 2266 | foreach_ip6_hop_by_hop_error |
| 2267 | #undef _ |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2268 | IP6_HOP_BY_HOP_N_ERROR, |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2269 | } ip6_hop_by_hop_error_t; |
Neale Ranns | 32e1c01 | 2016-11-22 17:07:28 +0000 | [diff] [blame] | 2270 | /* *INDENT-ON* */ |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2271 | |
| 2272 | /* |
| 2273 | * Primary h-b-h handler trace support |
| 2274 | * We work pretty hard on the problem for obvious reasons |
| 2275 | */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2276 | typedef struct |
| 2277 | { |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2278 | u32 next_index; |
| 2279 | u32 trace_len; |
| 2280 | u8 option_data[256]; |
| 2281 | } ip6_hop_by_hop_trace_t; |
| 2282 | |
Benoît Ganne | 47727c0 | 2019-02-12 13:35:08 +0100 | [diff] [blame] | 2283 | extern vlib_node_registration_t ip6_hop_by_hop_node; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2284 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2285 | static char *ip6_hop_by_hop_error_strings[] = { |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2286 | #define _(sym,string) string, |
| 2287 | foreach_ip6_hop_by_hop_error |
| 2288 | #undef _ |
| 2289 | }; |
| 2290 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2291 | #ifndef CLIB_MARCH_VARIANT |
Shwetha Bhandari | 78372a9 | 2017-01-18 12:43:54 +0530 | [diff] [blame] | 2292 | u8 * |
| 2293 | format_ip6_hop_by_hop_ext_hdr (u8 * s, va_list * args) |
| 2294 | { |
| 2295 | ip6_hop_by_hop_header_t *hbh0 = va_arg (*args, ip6_hop_by_hop_header_t *); |
| 2296 | int total_len = va_arg (*args, int); |
| 2297 | ip6_hop_by_hop_option_t *opt0, *limit0; |
| 2298 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
| 2299 | u8 type0; |
| 2300 | |
| 2301 | s = format (s, "IP6_HOP_BY_HOP: next protocol %d len %d total %d", |
| 2302 | hbh0->protocol, (hbh0->length + 1) << 3, total_len); |
| 2303 | |
| 2304 | opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1); |
| 2305 | limit0 = (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 + total_len); |
| 2306 | |
| 2307 | while (opt0 < limit0) |
| 2308 | { |
| 2309 | type0 = opt0->type; |
| 2310 | switch (type0) |
| 2311 | { |
| 2312 | case 0: /* Pad, just stop */ |
| 2313 | opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0 + 1); |
| 2314 | break; |
| 2315 | |
| 2316 | default: |
| 2317 | if (hm->trace[type0]) |
| 2318 | { |
| 2319 | s = (*hm->trace[type0]) (s, opt0); |
| 2320 | } |
| 2321 | else |
| 2322 | { |
| 2323 | s = |
| 2324 | format (s, "\n unrecognized option %d length %d", type0, |
| 2325 | opt0->length); |
| 2326 | } |
| 2327 | opt0 = |
| 2328 | (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length + |
| 2329 | sizeof (ip6_hop_by_hop_option_t)); |
| 2330 | break; |
| 2331 | } |
| 2332 | } |
| 2333 | return s; |
| 2334 | } |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2335 | #endif |
Shwetha Bhandari | 78372a9 | 2017-01-18 12:43:54 +0530 | [diff] [blame] | 2336 | |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2337 | static u8 * |
| 2338 | format_ip6_hop_by_hop_trace (u8 * s, va_list * args) |
| 2339 | { |
| 2340 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 2341 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2342 | ip6_hop_by_hop_trace_t *t = va_arg (*args, ip6_hop_by_hop_trace_t *); |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2343 | ip6_hop_by_hop_header_t *hbh0; |
| 2344 | ip6_hop_by_hop_option_t *opt0, *limit0; |
| 2345 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
| 2346 | |
| 2347 | u8 type0; |
| 2348 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2349 | hbh0 = (ip6_hop_by_hop_header_t *) t->option_data; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2350 | |
| 2351 | s = format (s, "IP6_HOP_BY_HOP: next index %d len %d traced %d", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2352 | t->next_index, (hbh0->length + 1) << 3, t->trace_len); |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2353 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2354 | opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1); |
| 2355 | limit0 = (ip6_hop_by_hop_option_t *) ((u8 *) hbh0) + t->trace_len; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2356 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2357 | while (opt0 < limit0) |
| 2358 | { |
| 2359 | type0 = opt0->type; |
| 2360 | switch (type0) |
| 2361 | { |
| 2362 | case 0: /* Pad, just stop */ |
| 2363 | opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0) + 1; |
| 2364 | break; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2365 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2366 | default: |
| 2367 | if (hm->trace[type0]) |
| 2368 | { |
| 2369 | s = (*hm->trace[type0]) (s, opt0); |
| 2370 | } |
| 2371 | else |
| 2372 | { |
| 2373 | s = |
| 2374 | format (s, "\n unrecognized option %d length %d", type0, |
| 2375 | opt0->length); |
| 2376 | } |
| 2377 | opt0 = |
| 2378 | (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length + |
| 2379 | sizeof (ip6_hop_by_hop_option_t)); |
| 2380 | break; |
| 2381 | } |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2382 | } |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2383 | return s; |
| 2384 | } |
| 2385 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2386 | always_inline u8 |
| 2387 | ip6_scan_hbh_options (vlib_buffer_t * b0, |
| 2388 | ip6_header_t * ip0, |
| 2389 | ip6_hop_by_hop_header_t * hbh0, |
| 2390 | ip6_hop_by_hop_option_t * opt0, |
| 2391 | ip6_hop_by_hop_option_t * limit0, u32 * next0) |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2392 | { |
| 2393 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
| 2394 | u8 type0; |
| 2395 | u8 error0 = 0; |
| 2396 | |
| 2397 | while (opt0 < limit0) |
| 2398 | { |
| 2399 | type0 = opt0->type; |
| 2400 | switch (type0) |
| 2401 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2402 | case 0: /* Pad1 */ |
| 2403 | opt0 = (ip6_hop_by_hop_option_t *) ((u8 *) opt0) + 1; |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2404 | continue; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2405 | case 1: /* PadN */ |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2406 | break; |
| 2407 | default: |
| 2408 | if (hm->options[type0]) |
| 2409 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2410 | if ((*hm->options[type0]) (b0, ip0, opt0) < 0) |
| 2411 | { |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2412 | error0 = IP6_HOP_BY_HOP_ERROR_FORMAT; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2413 | return (error0); |
| 2414 | } |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2415 | } |
| 2416 | else |
| 2417 | { |
| 2418 | /* Unrecognized mandatory option, check the two high order bits */ |
| 2419 | switch (opt0->type & HBH_OPTION_TYPE_HIGH_ORDER_BITS) |
| 2420 | { |
| 2421 | case HBH_OPTION_TYPE_SKIP_UNKNOWN: |
| 2422 | break; |
| 2423 | case HBH_OPTION_TYPE_DISCARD_UNKNOWN: |
| 2424 | error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION; |
| 2425 | *next0 = IP_LOOKUP_NEXT_DROP; |
| 2426 | break; |
| 2427 | case HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP: |
| 2428 | error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION; |
| 2429 | *next0 = IP_LOOKUP_NEXT_ICMP_ERROR; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2430 | icmp6_error_set_vnet_buffer (b0, ICMP6_parameter_problem, |
| 2431 | ICMP6_parameter_problem_unrecognized_option, |
| 2432 | (u8 *) opt0 - (u8 *) ip0); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2433 | break; |
| 2434 | case HBH_OPTION_TYPE_DISCARD_UNKNOWN_ICMP_NOT_MCAST: |
| 2435 | error0 = IP6_HOP_BY_HOP_ERROR_UNKNOWN_OPTION; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2436 | if (!ip6_address_is_multicast (&ip0->dst_address)) |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2437 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2438 | *next0 = IP_LOOKUP_NEXT_ICMP_ERROR; |
| 2439 | icmp6_error_set_vnet_buffer (b0, |
| 2440 | ICMP6_parameter_problem, |
| 2441 | ICMP6_parameter_problem_unrecognized_option, |
| 2442 | (u8 *) opt0 - (u8 *) ip0); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2443 | } |
| 2444 | else |
| 2445 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2446 | *next0 = IP_LOOKUP_NEXT_DROP; |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2447 | } |
| 2448 | break; |
| 2449 | } |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2450 | return (error0); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2451 | } |
| 2452 | } |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2453 | opt0 = |
| 2454 | (ip6_hop_by_hop_option_t *) (((u8 *) opt0) + opt0->length + |
| 2455 | sizeof (ip6_hop_by_hop_option_t)); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2456 | } |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2457 | return (error0); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2458 | } |
| 2459 | |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2460 | /* |
| 2461 | * Process the Hop-by-Hop Options header |
| 2462 | */ |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2463 | VLIB_NODE_FN (ip6_hop_by_hop_node) (vlib_main_t * vm, |
| 2464 | vlib_node_runtime_t * node, |
| 2465 | vlib_frame_t * frame) |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2466 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2467 | vlib_node_runtime_t *error_node = |
| 2468 | vlib_node_get_runtime (vm, ip6_hop_by_hop_node.index); |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2469 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
| 2470 | u32 n_left_from, *from, *to_next; |
| 2471 | ip_lookup_next_t next_index; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2472 | |
| 2473 | from = vlib_frame_vector_args (frame); |
| 2474 | n_left_from = frame->n_vectors; |
| 2475 | next_index = node->cached_next_index; |
| 2476 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2477 | while (n_left_from > 0) |
| 2478 | { |
| 2479 | u32 n_left_to_next; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2480 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2481 | vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2482 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2483 | while (n_left_from >= 4 && n_left_to_next >= 2) |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2484 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2485 | u32 bi0, bi1; |
| 2486 | vlib_buffer_t *b0, *b1; |
| 2487 | u32 next0, next1; |
| 2488 | ip6_header_t *ip0, *ip1; |
| 2489 | ip6_hop_by_hop_header_t *hbh0, *hbh1; |
| 2490 | ip6_hop_by_hop_option_t *opt0, *limit0, *opt1, *limit1; |
| 2491 | u8 error0 = 0, error1 = 0; |
| 2492 | |
| 2493 | /* Prefetch next iteration. */ |
| 2494 | { |
| 2495 | vlib_buffer_t *p2, *p3; |
| 2496 | |
| 2497 | p2 = vlib_get_buffer (vm, from[2]); |
| 2498 | p3 = vlib_get_buffer (vm, from[3]); |
| 2499 | |
| 2500 | vlib_prefetch_buffer_header (p2, LOAD); |
| 2501 | vlib_prefetch_buffer_header (p3, LOAD); |
| 2502 | |
| 2503 | CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD); |
| 2504 | CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2505 | } |
| 2506 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2507 | /* Speculatively enqueue b0, b1 to the current next frame */ |
| 2508 | to_next[0] = bi0 = from[0]; |
| 2509 | to_next[1] = bi1 = from[1]; |
| 2510 | from += 2; |
| 2511 | to_next += 2; |
| 2512 | n_left_from -= 2; |
| 2513 | n_left_to_next -= 2; |
| 2514 | |
| 2515 | b0 = vlib_get_buffer (vm, bi0); |
| 2516 | b1 = vlib_get_buffer (vm, bi1); |
| 2517 | |
| 2518 | /* Default use the next_index from the adjacency. A HBH option rarely redirects to a different node */ |
| 2519 | u32 adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX]; |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 2520 | ip_adjacency_t *adj0 = adj_get (adj_index0); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2521 | u32 adj_index1 = vnet_buffer (b1)->ip.adj_index[VLIB_TX]; |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 2522 | ip_adjacency_t *adj1 = adj_get (adj_index1); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2523 | |
| 2524 | /* Default use the next_index from the adjacency. A HBH option rarely redirects to a different node */ |
| 2525 | next0 = adj0->lookup_next_index; |
| 2526 | next1 = adj1->lookup_next_index; |
| 2527 | |
| 2528 | ip0 = vlib_buffer_get_current (b0); |
| 2529 | ip1 = vlib_buffer_get_current (b1); |
| 2530 | hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1); |
| 2531 | hbh1 = (ip6_hop_by_hop_header_t *) (ip1 + 1); |
| 2532 | opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1); |
| 2533 | opt1 = (ip6_hop_by_hop_option_t *) (hbh1 + 1); |
| 2534 | limit0 = |
| 2535 | (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 + |
| 2536 | ((hbh0->length + 1) << 3)); |
| 2537 | limit1 = |
| 2538 | (ip6_hop_by_hop_option_t *) ((u8 *) hbh1 + |
| 2539 | ((hbh1->length + 1) << 3)); |
| 2540 | |
| 2541 | /* |
| 2542 | * Basic validity checks |
| 2543 | */ |
| 2544 | if ((hbh0->length + 1) << 3 > |
| 2545 | clib_net_to_host_u16 (ip0->payload_length)) |
| 2546 | { |
| 2547 | error0 = IP6_HOP_BY_HOP_ERROR_FORMAT; |
| 2548 | next0 = IP_LOOKUP_NEXT_DROP; |
| 2549 | goto outdual; |
| 2550 | } |
| 2551 | /* Scan the set of h-b-h options, process ones that we understand */ |
| 2552 | error0 = ip6_scan_hbh_options (b0, ip0, hbh0, opt0, limit0, &next0); |
| 2553 | |
| 2554 | if ((hbh1->length + 1) << 3 > |
| 2555 | clib_net_to_host_u16 (ip1->payload_length)) |
| 2556 | { |
| 2557 | error1 = IP6_HOP_BY_HOP_ERROR_FORMAT; |
| 2558 | next1 = IP_LOOKUP_NEXT_DROP; |
| 2559 | goto outdual; |
| 2560 | } |
| 2561 | /* Scan the set of h-b-h options, process ones that we understand */ |
| 2562 | error1 = ip6_scan_hbh_options (b1, ip1, hbh1, opt1, limit1, &next1); |
| 2563 | |
| 2564 | outdual: |
| 2565 | /* Has the classifier flagged this buffer for special treatment? */ |
| 2566 | if (PREDICT_FALSE |
| 2567 | ((error0 == 0) |
| 2568 | && (vnet_buffer (b0)->l2_classify.opaque_index & OI_DECAP))) |
| 2569 | next0 = hm->next_override; |
| 2570 | |
| 2571 | /* Has the classifier flagged this buffer for special treatment? */ |
| 2572 | if (PREDICT_FALSE |
| 2573 | ((error1 == 0) |
| 2574 | && (vnet_buffer (b1)->l2_classify.opaque_index & OI_DECAP))) |
| 2575 | next1 = hm->next_override; |
| 2576 | |
| 2577 | if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) |
| 2578 | { |
| 2579 | if (b0->flags & VLIB_BUFFER_IS_TRACED) |
| 2580 | { |
| 2581 | ip6_hop_by_hop_trace_t *t = |
| 2582 | vlib_add_trace (vm, node, b0, sizeof (*t)); |
| 2583 | u32 trace_len = (hbh0->length + 1) << 3; |
| 2584 | t->next_index = next0; |
| 2585 | /* Capture the h-b-h option verbatim */ |
| 2586 | trace_len = |
| 2587 | trace_len < |
| 2588 | ARRAY_LEN (t->option_data) ? trace_len : |
| 2589 | ARRAY_LEN (t->option_data); |
| 2590 | t->trace_len = trace_len; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 2591 | clib_memcpy_fast (t->option_data, hbh0, trace_len); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2592 | } |
| 2593 | if (b1->flags & VLIB_BUFFER_IS_TRACED) |
| 2594 | { |
| 2595 | ip6_hop_by_hop_trace_t *t = |
| 2596 | vlib_add_trace (vm, node, b1, sizeof (*t)); |
| 2597 | u32 trace_len = (hbh1->length + 1) << 3; |
| 2598 | t->next_index = next1; |
| 2599 | /* Capture the h-b-h option verbatim */ |
| 2600 | trace_len = |
| 2601 | trace_len < |
| 2602 | ARRAY_LEN (t->option_data) ? trace_len : |
| 2603 | ARRAY_LEN (t->option_data); |
| 2604 | t->trace_len = trace_len; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 2605 | clib_memcpy_fast (t->option_data, hbh1, trace_len); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2606 | } |
| 2607 | |
| 2608 | } |
| 2609 | |
| 2610 | b0->error = error_node->errors[error0]; |
| 2611 | b1->error = error_node->errors[error1]; |
| 2612 | |
| 2613 | /* verify speculative enqueue, maybe switch current next frame */ |
| 2614 | vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next, |
| 2615 | n_left_to_next, bi0, bi1, next0, |
| 2616 | next1); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2617 | } |
| 2618 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2619 | while (n_left_from > 0 && n_left_to_next > 0) |
| 2620 | { |
| 2621 | u32 bi0; |
| 2622 | vlib_buffer_t *b0; |
| 2623 | u32 next0; |
| 2624 | ip6_header_t *ip0; |
| 2625 | ip6_hop_by_hop_header_t *hbh0; |
| 2626 | ip6_hop_by_hop_option_t *opt0, *limit0; |
| 2627 | u8 error0 = 0; |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2628 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2629 | /* Speculatively enqueue b0 to the current next frame */ |
| 2630 | bi0 = from[0]; |
| 2631 | to_next[0] = bi0; |
| 2632 | from += 1; |
| 2633 | to_next += 1; |
| 2634 | n_left_from -= 1; |
| 2635 | n_left_to_next -= 1; |
| 2636 | |
| 2637 | b0 = vlib_get_buffer (vm, bi0); |
| 2638 | /* |
| 2639 | * Default use the next_index from the adjacency. |
| 2640 | * A HBH option rarely redirects to a different node |
| 2641 | */ |
| 2642 | u32 adj_index0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX]; |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 2643 | ip_adjacency_t *adj0 = adj_get (adj_index0); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2644 | next0 = adj0->lookup_next_index; |
| 2645 | |
| 2646 | ip0 = vlib_buffer_get_current (b0); |
| 2647 | hbh0 = (ip6_hop_by_hop_header_t *) (ip0 + 1); |
| 2648 | opt0 = (ip6_hop_by_hop_option_t *) (hbh0 + 1); |
| 2649 | limit0 = |
| 2650 | (ip6_hop_by_hop_option_t *) ((u8 *) hbh0 + |
| 2651 | ((hbh0->length + 1) << 3)); |
| 2652 | |
| 2653 | /* |
| 2654 | * Basic validity checks |
| 2655 | */ |
| 2656 | if ((hbh0->length + 1) << 3 > |
| 2657 | clib_net_to_host_u16 (ip0->payload_length)) |
| 2658 | { |
| 2659 | error0 = IP6_HOP_BY_HOP_ERROR_FORMAT; |
| 2660 | next0 = IP_LOOKUP_NEXT_DROP; |
| 2661 | goto out0; |
| 2662 | } |
| 2663 | |
| 2664 | /* Scan the set of h-b-h options, process ones that we understand */ |
| 2665 | error0 = ip6_scan_hbh_options (b0, ip0, hbh0, opt0, limit0, &next0); |
| 2666 | |
| 2667 | out0: |
| 2668 | /* Has the classifier flagged this buffer for special treatment? */ |
| 2669 | if (PREDICT_FALSE |
| 2670 | ((error0 == 0) |
| 2671 | && (vnet_buffer (b0)->l2_classify.opaque_index & OI_DECAP))) |
| 2672 | next0 = hm->next_override; |
| 2673 | |
| 2674 | if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) |
| 2675 | { |
| 2676 | ip6_hop_by_hop_trace_t *t = |
| 2677 | vlib_add_trace (vm, node, b0, sizeof (*t)); |
| 2678 | u32 trace_len = (hbh0->length + 1) << 3; |
| 2679 | t->next_index = next0; |
| 2680 | /* Capture the h-b-h option verbatim */ |
| 2681 | trace_len = |
| 2682 | trace_len < |
| 2683 | ARRAY_LEN (t->option_data) ? trace_len : |
| 2684 | ARRAY_LEN (t->option_data); |
| 2685 | t->trace_len = trace_len; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 2686 | clib_memcpy_fast (t->option_data, hbh0, trace_len); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2687 | } |
| 2688 | |
| 2689 | b0->error = error_node->errors[error0]; |
| 2690 | |
| 2691 | /* verify speculative enqueue, maybe switch current next frame */ |
| 2692 | vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, |
| 2693 | n_left_to_next, bi0, next0); |
| 2694 | } |
| 2695 | vlib_put_next_frame (vm, node, next_index, n_left_to_next); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2696 | } |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2697 | return frame->n_vectors; |
| 2698 | } |
| 2699 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2700 | /* *INDENT-OFF* */ |
| 2701 | VLIB_REGISTER_NODE (ip6_hop_by_hop_node) = |
| 2702 | { |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2703 | .name = "ip6-hop-by-hop", |
Ole Troan | 964f93e | 2016-06-10 13:22:36 +0200 | [diff] [blame] | 2704 | .sibling_of = "ip6-lookup", |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2705 | .vector_size = sizeof (u32), |
| 2706 | .format_trace = format_ip6_hop_by_hop_trace, |
| 2707 | .type = VLIB_NODE_TYPE_INTERNAL, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2708 | .n_errors = ARRAY_LEN (ip6_hop_by_hop_error_strings), |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2709 | .error_strings = ip6_hop_by_hop_error_strings, |
Ole Troan | 964f93e | 2016-06-10 13:22:36 +0200 | [diff] [blame] | 2710 | .n_next_nodes = 0, |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2711 | }; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2712 | /* *INDENT-ON* */ |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2713 | |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2714 | static clib_error_t * |
| 2715 | ip6_hop_by_hop_init (vlib_main_t * vm) |
| 2716 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2717 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 2718 | clib_memset (hm->options, 0, sizeof (hm->options)); |
| 2719 | clib_memset (hm->trace, 0, sizeof (hm->trace)); |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2720 | hm->next_override = IP6_LOOKUP_NEXT_POP_HOP_BY_HOP; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2721 | return (0); |
| 2722 | } |
| 2723 | |
| 2724 | VLIB_INIT_FUNCTION (ip6_hop_by_hop_init); |
| 2725 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2726 | #ifndef CLIB_MARCH_VARIANT |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2727 | void |
| 2728 | ip6_hbh_set_next_override (uword next) |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2729 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2730 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
Shwetha | a91cbe6 | 2016-08-08 15:51:04 +0100 | [diff] [blame] | 2731 | |
| 2732 | hm->next_override = next; |
| 2733 | } |
| 2734 | |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2735 | int |
| 2736 | ip6_hbh_register_option (u8 option, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2737 | int options (vlib_buffer_t * b, ip6_header_t * ip, |
| 2738 | ip6_hop_by_hop_option_t * opt), |
| 2739 | u8 * trace (u8 * s, ip6_hop_by_hop_option_t * opt)) |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2740 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2741 | ip6_main_t *im = &ip6_main; |
| 2742 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2743 | |
Neale Ranns | 756cd94 | 2018-04-06 09:18:11 -0700 | [diff] [blame] | 2744 | ASSERT ((u32) option < ARRAY_LEN (hm->options)); |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2745 | |
| 2746 | /* Already registered */ |
| 2747 | if (hm->options[option]) |
| 2748 | return (-1); |
| 2749 | |
| 2750 | hm->options[option] = options; |
| 2751 | hm->trace[option] = trace; |
| 2752 | |
| 2753 | /* Set global variable */ |
| 2754 | im->hbh_enabled = 1; |
| 2755 | |
| 2756 | return (0); |
| 2757 | } |
| 2758 | |
| 2759 | int |
| 2760 | ip6_hbh_unregister_option (u8 option) |
| 2761 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2762 | ip6_main_t *im = &ip6_main; |
| 2763 | ip6_hop_by_hop_main_t *hm = &ip6_hop_by_hop_main; |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2764 | |
Neale Ranns | 756cd94 | 2018-04-06 09:18:11 -0700 | [diff] [blame] | 2765 | ASSERT ((u32) option < ARRAY_LEN (hm->options)); |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2766 | |
| 2767 | /* Not registered */ |
| 2768 | if (!hm->options[option]) |
| 2769 | return (-1); |
| 2770 | |
| 2771 | hm->options[option] = NULL; |
| 2772 | hm->trace[option] = NULL; |
| 2773 | |
| 2774 | /* Disable global knob if this was the last option configured */ |
| 2775 | int i; |
| 2776 | bool found = false; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2777 | for (i = 0; i < 256; i++) |
| 2778 | { |
| 2779 | if (hm->options[option]) |
| 2780 | { |
| 2781 | found = true; |
| 2782 | break; |
| 2783 | } |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2784 | } |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2785 | if (!found) |
| 2786 | im->hbh_enabled = 0; |
| 2787 | |
| 2788 | return (0); |
| 2789 | } |
| 2790 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2791 | /* Global IP6 main. */ |
| 2792 | ip6_main_t ip6_main; |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2793 | #endif |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2794 | |
| 2795 | static clib_error_t * |
| 2796 | ip6_lookup_init (vlib_main_t * vm) |
| 2797 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2798 | ip6_main_t *im = &ip6_main; |
| 2799 | clib_error_t *error; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2800 | uword i; |
| 2801 | |
Damjan Marion | 8b3191e | 2016-11-09 19:54:20 +0100 | [diff] [blame] | 2802 | if ((error = vlib_call_init_function (vm, vnet_feature_init))) |
| 2803 | return error; |
| 2804 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2805 | for (i = 0; i < ARRAY_LEN (im->fib_masks); i++) |
| 2806 | { |
| 2807 | u32 j, i0, i1; |
| 2808 | |
| 2809 | i0 = i / 32; |
| 2810 | i1 = i % 32; |
| 2811 | |
| 2812 | for (j = 0; j < i0; j++) |
| 2813 | im->fib_masks[i].as_u32[j] = ~0; |
| 2814 | |
| 2815 | if (i1) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2816 | im->fib_masks[i].as_u32[i0] = |
| 2817 | clib_host_to_net_u32 (pow2_mask (i1) << (32 - i1)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2818 | } |
| 2819 | |
| 2820 | ip_lookup_init (&im->lookup_main, /* is_ip6 */ 1); |
| 2821 | |
| 2822 | if (im->lookup_table_nbuckets == 0) |
| 2823 | im->lookup_table_nbuckets = IP6_FIB_DEFAULT_HASH_NUM_BUCKETS; |
| 2824 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2825 | im->lookup_table_nbuckets = 1 << max_log2 (im->lookup_table_nbuckets); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2826 | |
| 2827 | if (im->lookup_table_size == 0) |
| 2828 | im->lookup_table_size = IP6_FIB_DEFAULT_HASH_MEMORY_SIZE; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2829 | |
Neale Ranns | ae80983 | 2018-11-23 09:00:27 -0800 | [diff] [blame] | 2830 | clib_bihash_init_24_8 (&(im->ip6_table[IP6_FIB_TABLE_FWDING].ip6_hash), |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2831 | "ip6 FIB fwding table", |
| 2832 | im->lookup_table_nbuckets, im->lookup_table_size); |
Neale Ranns | ae80983 | 2018-11-23 09:00:27 -0800 | [diff] [blame] | 2833 | clib_bihash_init_24_8 (&im->ip6_table[IP6_FIB_TABLE_NON_FWDING].ip6_hash, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2834 | "ip6 FIB non-fwding table", |
| 2835 | im->lookup_table_nbuckets, im->lookup_table_size); |
Neale Ranns | ae80983 | 2018-11-23 09:00:27 -0800 | [diff] [blame] | 2836 | clib_bihash_init_40_8 (&im->ip6_mtable.ip6_mhash, |
| 2837 | "ip6 mFIB table", |
| 2838 | im->lookup_table_nbuckets, im->lookup_table_size); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 2839 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2840 | /* Create FIB with index 0 and table id of 0. */ |
Neale Ranns | 1500254 | 2017-09-10 04:39:11 -0700 | [diff] [blame] | 2841 | fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, 0, |
| 2842 | FIB_SOURCE_DEFAULT_ROUTE); |
| 2843 | mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP6, 0, |
| 2844 | MFIB_SOURCE_DEFAULT_ROUTE); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2845 | |
| 2846 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2847 | pg_node_t *pn; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2848 | pn = pg_get_node (ip6_lookup_node.index); |
| 2849 | pn->unformat_edit = unformat_pg_ip6_header; |
| 2850 | } |
| 2851 | |
Ole Troan | 944f548 | 2016-05-24 11:56:58 +0200 | [diff] [blame] | 2852 | /* Unless explicitly configured, don't process HBH options */ |
| 2853 | im->hbh_enabled = 0; |
| 2854 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2855 | { |
| 2856 | icmp6_neighbor_solicitation_header_t p; |
| 2857 | |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 2858 | clib_memset (&p, 0, sizeof (p)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2859 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2860 | p.ip.ip_version_traffic_class_and_flow_label = |
| 2861 | clib_host_to_net_u32 (0x6 << 28); |
| 2862 | p.ip.payload_length = |
| 2863 | clib_host_to_net_u16 (sizeof (p) - |
| 2864 | STRUCT_OFFSET_OF |
| 2865 | (icmp6_neighbor_solicitation_header_t, neighbor)); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2866 | p.ip.protocol = IP_PROTOCOL_ICMP6; |
| 2867 | p.ip.hop_limit = 255; |
| 2868 | ip6_set_solicited_node_multicast_address (&p.ip.dst_address, 0); |
| 2869 | |
| 2870 | p.neighbor.icmp.type = ICMP6_neighbor_solicitation; |
| 2871 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2872 | p.link_layer_option.header.type = |
| 2873 | ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address; |
| 2874 | p.link_layer_option.header.n_data_u64s = |
| 2875 | sizeof (p.link_layer_option) / sizeof (u64); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2876 | |
| 2877 | vlib_packet_template_init (vm, |
| 2878 | &im->discover_neighbor_packet_template, |
| 2879 | &p, sizeof (p), |
| 2880 | /* alloc chunk size */ 8, |
| 2881 | "ip6 neighbor discovery"); |
| 2882 | } |
| 2883 | |
Dave Barach | 203c632 | 2016-06-26 10:29:03 -0400 | [diff] [blame] | 2884 | return error; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2885 | } |
| 2886 | |
| 2887 | VLIB_INIT_FUNCTION (ip6_lookup_init); |
| 2888 | |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2889 | static clib_error_t * |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2890 | test_ip6_link_command_fn (vlib_main_t * vm, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2891 | unformat_input_t * input, vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2892 | { |
| 2893 | u8 mac[6]; |
| 2894 | ip6_address_t _a, *a = &_a; |
| 2895 | |
| 2896 | if (unformat (input, "%U", unformat_ethernet_address, mac)) |
| 2897 | { |
| 2898 | ip6_link_local_address_from_ethernet_mac_address (a, mac); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2899 | vlib_cli_output (vm, "Link local address: %U", format_ip6_address, a); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2900 | ip6_ethernet_mac_address_from_link_local_address (mac, a); |
| 2901 | vlib_cli_output (vm, "Original MAC address: %U", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2902 | format_ethernet_address, mac); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2903 | } |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2904 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2905 | return 0; |
| 2906 | } |
| 2907 | |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 2908 | /*? |
| 2909 | * This command converts the given MAC Address into an IPv6 link-local |
| 2910 | * address. |
| 2911 | * |
| 2912 | * @cliexpar |
| 2913 | * Example of how to create an IPv6 link-local address: |
| 2914 | * @cliexstart{test ip6 link 16:d9:e0:91:79:86} |
| 2915 | * Link local address: fe80::14d9:e0ff:fe91:7986 |
| 2916 | * Original MAC address: 16:d9:e0:91:79:86 |
| 2917 | * @cliexend |
| 2918 | ?*/ |
| 2919 | /* *INDENT-OFF* */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2920 | VLIB_CLI_COMMAND (test_link_command, static) = |
| 2921 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2922 | .path = "test ip6 link", |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2923 | .function = test_ip6_link_command_fn, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2924 | .short_help = "test ip6 link <mac-address>", |
| 2925 | }; |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 2926 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2927 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2928 | #ifndef CLIB_MARCH_VARIANT |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2929 | int |
| 2930 | vnet_set_ip6_flow_hash (u32 table_id, u32 flow_hash_config) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2931 | { |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 2932 | u32 fib_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2933 | |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 2934 | fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2935 | |
Neale Ranns | 107e7d4 | 2017-04-11 09:55:19 -0700 | [diff] [blame] | 2936 | if (~0 == fib_index) |
| 2937 | return VNET_API_ERROR_NO_SUCH_FIB; |
| 2938 | |
Neale Ranns | 227038a | 2017-04-21 01:07:59 -0700 | [diff] [blame] | 2939 | fib_table_set_flow_hash_config (fib_index, FIB_PROTOCOL_IP6, |
| 2940 | flow_hash_config); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2941 | |
Neale Ranns | 227038a | 2017-04-21 01:07:59 -0700 | [diff] [blame] | 2942 | return 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2943 | } |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 2944 | #endif |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2945 | |
| 2946 | static clib_error_t * |
| 2947 | set_ip6_flow_hash_command_fn (vlib_main_t * vm, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2948 | unformat_input_t * input, |
| 2949 | vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2950 | { |
| 2951 | int matched = 0; |
| 2952 | u32 table_id = 0; |
| 2953 | u32 flow_hash_config = 0; |
| 2954 | int rv; |
| 2955 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2956 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 2957 | { |
| 2958 | if (unformat (input, "table %d", &table_id)) |
| 2959 | matched = 1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2960 | #define _(a,v) \ |
| 2961 | else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;} |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2962 | foreach_flow_hash_bit |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2963 | #undef _ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2964 | else |
| 2965 | break; |
| 2966 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2967 | |
| 2968 | if (matched == 0) |
| 2969 | return clib_error_return (0, "unknown input `%U'", |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 2970 | format_unformat_error, input); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2971 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2972 | rv = vnet_set_ip6_flow_hash (table_id, flow_hash_config); |
| 2973 | switch (rv) |
| 2974 | { |
Neale Ranns | 227038a | 2017-04-21 01:07:59 -0700 | [diff] [blame] | 2975 | case 0: |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2976 | break; |
| 2977 | |
| 2978 | case -1: |
| 2979 | return clib_error_return (0, "no such FIB table %d", table_id); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2980 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2981 | default: |
| 2982 | clib_warning ("BUG: illegal flow hash config 0x%x", flow_hash_config); |
| 2983 | break; |
| 2984 | } |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 2985 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 2986 | return 0; |
| 2987 | } |
| 2988 | |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 2989 | /*? |
| 2990 | * Configure the set of IPv6 fields used by the flow hash. |
| 2991 | * |
| 2992 | * @cliexpar |
| 2993 | * @parblock |
| 2994 | * Example of how to set the flow hash on a given table: |
Billy McFall | ebb9a6a | 2016-10-17 11:35:32 -0400 | [diff] [blame] | 2995 | * @cliexcmd{set ip6 flow-hash table 8 dst sport dport proto} |
| 2996 | * |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 2997 | * Example of display the configured flow hash: |
| 2998 | * @cliexstart{show ip6 fib} |
Billy McFall | ebb9a6a | 2016-10-17 11:35:32 -0400 | [diff] [blame] | 2999 | * ipv6-VRF:0, fib_index 0, flow hash: src dst sport dport proto |
| 3000 | * @::/0 |
| 3001 | * unicast-ip6-chain |
| 3002 | * [@0]: dpo-load-balance: [index:5 buckets:1 uRPF:5 to:[0:0]] |
| 3003 | * [0] [@0]: dpo-drop ip6 |
| 3004 | * fe80::/10 |
| 3005 | * unicast-ip6-chain |
| 3006 | * [@0]: dpo-load-balance: [index:10 buckets:1 uRPF:10 to:[0:0]] |
| 3007 | * [0] [@2]: dpo-receive |
| 3008 | * ff02::1/128 |
| 3009 | * unicast-ip6-chain |
| 3010 | * [@0]: dpo-load-balance: [index:8 buckets:1 uRPF:8 to:[0:0]] |
| 3011 | * [0] [@2]: dpo-receive |
| 3012 | * ff02::2/128 |
| 3013 | * unicast-ip6-chain |
| 3014 | * [@0]: dpo-load-balance: [index:7 buckets:1 uRPF:7 to:[0:0]] |
| 3015 | * [0] [@2]: dpo-receive |
| 3016 | * ff02::16/128 |
| 3017 | * unicast-ip6-chain |
| 3018 | * [@0]: dpo-load-balance: [index:9 buckets:1 uRPF:9 to:[0:0]] |
| 3019 | * [0] [@2]: dpo-receive |
| 3020 | * ff02::1:ff00:0/104 |
| 3021 | * unicast-ip6-chain |
| 3022 | * [@0]: dpo-load-balance: [index:6 buckets:1 uRPF:6 to:[0:0]] |
| 3023 | * [0] [@2]: dpo-receive |
| 3024 | * ipv6-VRF:8, fib_index 1, flow hash: dst sport dport proto |
| 3025 | * @::/0 |
| 3026 | * unicast-ip6-chain |
| 3027 | * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]] |
| 3028 | * [0] [@0]: dpo-drop ip6 |
| 3029 | * @::a:1:1:0:4/126 |
| 3030 | * unicast-ip6-chain |
| 3031 | * [@0]: dpo-load-balance: [index:27 buckets:1 uRPF:26 to:[0:0]] |
| 3032 | * [0] [@4]: ipv6-glean: af_packet0 |
| 3033 | * @::a:1:1:0:7/128 |
| 3034 | * unicast-ip6-chain |
| 3035 | * [@0]: dpo-load-balance: [index:28 buckets:1 uRPF:27 to:[0:0]] |
| 3036 | * [0] [@2]: dpo-receive: @::a:1:1:0:7 on af_packet0 |
| 3037 | * fe80::/10 |
| 3038 | * unicast-ip6-chain |
| 3039 | * [@0]: dpo-load-balance: [index:26 buckets:1 uRPF:25 to:[0:0]] |
| 3040 | * [0] [@2]: dpo-receive |
| 3041 | * fe80::fe:3eff:fe3e:9222/128 |
| 3042 | * unicast-ip6-chain |
| 3043 | * [@0]: dpo-load-balance: [index:29 buckets:1 uRPF:28 to:[0:0]] |
| 3044 | * [0] [@2]: dpo-receive: fe80::fe:3eff:fe3e:9222 on af_packet0 |
| 3045 | * ff02::1/128 |
| 3046 | * unicast-ip6-chain |
| 3047 | * [@0]: dpo-load-balance: [index:24 buckets:1 uRPF:23 to:[0:0]] |
| 3048 | * [0] [@2]: dpo-receive |
| 3049 | * ff02::2/128 |
| 3050 | * unicast-ip6-chain |
| 3051 | * [@0]: dpo-load-balance: [index:23 buckets:1 uRPF:22 to:[0:0]] |
| 3052 | * [0] [@2]: dpo-receive |
| 3053 | * ff02::16/128 |
| 3054 | * unicast-ip6-chain |
| 3055 | * [@0]: dpo-load-balance: [index:25 buckets:1 uRPF:24 to:[0:0]] |
| 3056 | * [0] [@2]: dpo-receive |
| 3057 | * ff02::1:ff00:0/104 |
| 3058 | * unicast-ip6-chain |
| 3059 | * [@0]: dpo-load-balance: [index:22 buckets:1 uRPF:21 to:[0:0]] |
| 3060 | * [0] [@2]: dpo-receive |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 3061 | * @cliexend |
| 3062 | * @endparblock |
| 3063 | ?*/ |
| 3064 | /* *INDENT-OFF* */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3065 | VLIB_CLI_COMMAND (set_ip6_flow_hash_command, static) = |
| 3066 | { |
| 3067 | .path = "set ip6 flow-hash", |
| 3068 | .short_help = |
| 3069 | "set ip6 flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]", |
| 3070 | .function = set_ip6_flow_hash_command_fn, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3071 | }; |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 3072 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3073 | |
| 3074 | static clib_error_t * |
| 3075 | show_ip6_local_command_fn (vlib_main_t * vm, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3076 | unformat_input_t * input, vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3077 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3078 | ip6_main_t *im = &ip6_main; |
| 3079 | ip_lookup_main_t *lm = &im->lookup_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3080 | int i; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 3081 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3082 | vlib_cli_output (vm, "Protocols handled by ip6_local"); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3083 | for (i = 0; i < ARRAY_LEN (lm->local_next_by_ip_protocol); i++) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3084 | { |
| 3085 | if (lm->local_next_by_ip_protocol[i] != IP_LOCAL_NEXT_PUNT) |
Pierre Pfister | 1bfd372 | 2017-09-18 11:40:32 +0200 | [diff] [blame] | 3086 | { |
| 3087 | |
| 3088 | u32 node_index = vlib_get_node (vm, |
| 3089 | ip6_local_node.index)-> |
| 3090 | next_nodes[lm->local_next_by_ip_protocol[i]]; |
| 3091 | vlib_cli_output (vm, "%d: %U", i, format_vlib_node_name, vm, |
| 3092 | node_index); |
| 3093 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3094 | } |
| 3095 | return 0; |
| 3096 | } |
| 3097 | |
| 3098 | |
| 3099 | |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 3100 | /*? |
| 3101 | * Display the set of protocols handled by the local IPv6 stack. |
| 3102 | * |
| 3103 | * @cliexpar |
| 3104 | * Example of how to display local protocol table: |
| 3105 | * @cliexstart{show ip6 local} |
| 3106 | * Protocols handled by ip6_local |
| 3107 | * 17 |
| 3108 | * 43 |
| 3109 | * 58 |
| 3110 | * 115 |
| 3111 | * @cliexend |
| 3112 | ?*/ |
| 3113 | /* *INDENT-OFF* */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3114 | VLIB_CLI_COMMAND (show_ip6_local, static) = |
| 3115 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3116 | .path = "show ip6 local", |
| 3117 | .function = show_ip6_local_command_fn, |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 3118 | .short_help = "show ip6 local", |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3119 | }; |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 3120 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3121 | |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 3122 | #ifndef CLIB_MARCH_VARIANT |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3123 | int |
| 3124 | vnet_set_ip6_classify_intfc (vlib_main_t * vm, u32 sw_if_index, |
| 3125 | u32 table_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3126 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3127 | vnet_main_t *vnm = vnet_get_main (); |
| 3128 | vnet_interface_main_t *im = &vnm->interface_main; |
| 3129 | ip6_main_t *ipm = &ip6_main; |
| 3130 | ip_lookup_main_t *lm = &ipm->lookup_main; |
| 3131 | vnet_classify_main_t *cm = &vnet_classify_main; |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3132 | ip6_address_t *if_addr; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3133 | |
| 3134 | if (pool_is_free_index (im->sw_interfaces, sw_if_index)) |
| 3135 | return VNET_API_ERROR_NO_MATCHING_INTERFACE; |
| 3136 | |
| 3137 | if (table_index != ~0 && pool_is_free_index (cm->tables, table_index)) |
| 3138 | return VNET_API_ERROR_NO_SUCH_ENTRY; |
| 3139 | |
| 3140 | vec_validate (lm->classify_table_index_by_sw_if_index, sw_if_index); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3141 | lm->classify_table_index_by_sw_if_index[sw_if_index] = table_index; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3142 | |
Neale Ranns | 6cfc39c | 2017-02-14 01:44:25 -0800 | [diff] [blame] | 3143 | if_addr = ip6_interface_first_address (ipm, sw_if_index); |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3144 | |
| 3145 | if (NULL != if_addr) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3146 | { |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3147 | fib_prefix_t pfx = { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3148 | .fp_len = 128, |
| 3149 | .fp_proto = FIB_PROTOCOL_IP6, |
| 3150 | .fp_addr.ip6 = *if_addr, |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3151 | }; |
| 3152 | u32 fib_index; |
| 3153 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3154 | fib_index = fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4, |
| 3155 | sw_if_index); |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3156 | |
| 3157 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3158 | if (table_index != (u32) ~ 0) |
| 3159 | { |
| 3160 | dpo_id_t dpo = DPO_INVALID; |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3161 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3162 | dpo_set (&dpo, |
| 3163 | DPO_CLASSIFY, |
| 3164 | DPO_PROTO_IP6, |
| 3165 | classify_dpo_create (DPO_PROTO_IP6, table_index)); |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3166 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3167 | fib_table_entry_special_dpo_add (fib_index, |
| 3168 | &pfx, |
| 3169 | FIB_SOURCE_CLASSIFY, |
| 3170 | FIB_ENTRY_FLAG_NONE, &dpo); |
| 3171 | dpo_reset (&dpo); |
| 3172 | } |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3173 | else |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3174 | { |
| 3175 | fib_table_entry_special_remove (fib_index, |
| 3176 | &pfx, FIB_SOURCE_CLASSIFY); |
| 3177 | } |
| 3178 | } |
Neale Ranns | df089a8 | 2016-10-02 16:39:06 +0100 | [diff] [blame] | 3179 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3180 | return 0; |
| 3181 | } |
Damjan Marion | 3817350 | 2019-02-13 19:30:09 +0100 | [diff] [blame] | 3182 | #endif |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3183 | |
| 3184 | static clib_error_t * |
| 3185 | set_ip6_classify_command_fn (vlib_main_t * vm, |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3186 | unformat_input_t * input, |
| 3187 | vlib_cli_command_t * cmd) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3188 | { |
| 3189 | u32 table_index = ~0; |
| 3190 | int table_index_set = 0; |
| 3191 | u32 sw_if_index = ~0; |
| 3192 | int rv; |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 3193 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3194 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 3195 | { |
| 3196 | if (unformat (input, "table-index %d", &table_index)) |
| 3197 | table_index_set = 1; |
| 3198 | else if (unformat (input, "intfc %U", unformat_vnet_sw_interface, |
| 3199 | vnet_get_main (), &sw_if_index)) |
| 3200 | ; |
| 3201 | else |
| 3202 | break; |
| 3203 | } |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 3204 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3205 | if (table_index_set == 0) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3206 | return clib_error_return (0, "classify table-index must be specified"); |
Dave Barach | 75fc854 | 2016-10-11 16:16:02 -0400 | [diff] [blame] | 3207 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3208 | if (sw_if_index == ~0) |
| 3209 | return clib_error_return (0, "interface / subif must be specified"); |
| 3210 | |
| 3211 | rv = vnet_set_ip6_classify_intfc (vm, sw_if_index, table_index); |
| 3212 | |
| 3213 | switch (rv) |
| 3214 | { |
| 3215 | case 0: |
| 3216 | break; |
| 3217 | |
| 3218 | case VNET_API_ERROR_NO_MATCHING_INTERFACE: |
| 3219 | return clib_error_return (0, "No such interface"); |
| 3220 | |
| 3221 | case VNET_API_ERROR_NO_SUCH_ENTRY: |
| 3222 | return clib_error_return (0, "No such classifier table"); |
| 3223 | } |
| 3224 | return 0; |
| 3225 | } |
| 3226 | |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 3227 | /*? |
| 3228 | * Assign a classification table to an interface. The classification |
| 3229 | * table is created using the '<em>classify table</em>' and '<em>classify session</em>' |
| 3230 | * commands. Once the table is create, use this command to filter packets |
| 3231 | * on an interface. |
| 3232 | * |
| 3233 | * @cliexpar |
| 3234 | * Example of how to assign a classification table to an interface: |
| 3235 | * @cliexcmd{set ip6 classify intfc GigabitEthernet2/0/0 table-index 1} |
| 3236 | ?*/ |
| 3237 | /* *INDENT-OFF* */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3238 | VLIB_CLI_COMMAND (set_ip6_classify_command, static) = |
| 3239 | { |
| 3240 | .path = "set ip6 classify", |
| 3241 | .short_help = |
| 3242 | "set ip6 classify intfc <interface> table-index <classify-idx>", |
| 3243 | .function = set_ip6_classify_command_fn, |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3244 | }; |
Billy McFall | 0683c9c | 2016-10-13 08:27:31 -0400 | [diff] [blame] | 3245 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3246 | |
| 3247 | static clib_error_t * |
| 3248 | ip6_config (vlib_main_t * vm, unformat_input_t * input) |
| 3249 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3250 | ip6_main_t *im = &ip6_main; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3251 | uword heapsize = 0; |
| 3252 | u32 tmp; |
| 3253 | u32 nbuckets = 0; |
| 3254 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3255 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 3256 | { |
| 3257 | if (unformat (input, "hash-buckets %d", &tmp)) |
| 3258 | nbuckets = tmp; |
Neale Ranns | 1ec3652 | 2017-11-29 05:20:37 -0800 | [diff] [blame] | 3259 | else if (unformat (input, "heap-size %U", |
| 3260 | unformat_memory_size, &heapsize)) |
| 3261 | ; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3262 | else |
| 3263 | return clib_error_return (0, "unknown input '%U'", |
| 3264 | format_unformat_error, input); |
| 3265 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 3266 | |
| 3267 | im->lookup_table_nbuckets = nbuckets; |
| 3268 | im->lookup_table_size = heapsize; |
| 3269 | |
| 3270 | return 0; |
| 3271 | } |
| 3272 | |
| 3273 | VLIB_EARLY_CONFIG_FUNCTION (ip6_config, "ip6"); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 3274 | |
| 3275 | /* |
| 3276 | * fd.io coding-style-patch-verification: ON |
| 3277 | * |
| 3278 | * Local Variables: |
| 3279 | * eval: (c-set-style "gnu") |
| 3280 | * End: |
| 3281 | */ |