Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2015 Cisco and/or its affiliates. |
| 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 | * ip6/packet.h: ip6 packet format |
| 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 | #ifndef included_ip6_packet_h |
| 41 | #define included_ip6_packet_h |
| 42 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 43 | #include <vnet/tcp/tcp_packet.h> |
Pierre Pfister | 1dabaaf | 2016-04-25 14:15:15 +0100 | [diff] [blame] | 44 | #include <vnet/ip/ip4_packet.h> |
| 45 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 46 | typedef union |
| 47 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 48 | u8 as_u8[16]; |
| 49 | u16 as_u16[8]; |
| 50 | u32 as_u32[4]; |
| 51 | u64 as_u64[2]; |
| 52 | uword as_uword[16 / sizeof (uword)]; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 53 | } |
| 54 | ip6_address_t; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 55 | |
Damjan Marion | a35cc14 | 2018-03-16 01:25:27 +0100 | [diff] [blame] | 56 | typedef struct |
| 57 | { |
| 58 | ip6_address_t addr, mask; |
| 59 | } ip6_address_and_mask_t; |
| 60 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 61 | /* Packed so that the mhash key doesn't include uninitialized pad bytes */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 62 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 63 | typedef CLIB_PACKED (struct { |
| 64 | /* IP address must be first for ip_interface_address_get_address() to work */ |
| 65 | ip6_address_t ip6_addr; |
| 66 | u32 fib_index; |
| 67 | }) ip6_address_fib_t; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 68 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 69 | |
Neale Ranns | d0df49f | 2018-08-08 01:06:40 -0700 | [diff] [blame] | 70 | typedef enum |
| 71 | { |
| 72 | IP46_TYPE_ANY, |
| 73 | IP46_TYPE_IP4, |
| 74 | IP46_TYPE_IP6 |
| 75 | } ip46_type_t; |
| 76 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 77 | /* *INDENT-OFF* */ |
Neale Ranns | c87b66c | 2019-02-07 07:26:12 -0800 | [diff] [blame] | 78 | typedef CLIB_PACKED (union ip46_address_t_ { |
Pierre Pfister | 1dabaaf | 2016-04-25 14:15:15 +0100 | [diff] [blame] | 79 | struct { |
| 80 | u32 pad[3]; |
| 81 | ip4_address_t ip4; |
| 82 | }; |
| 83 | ip6_address_t ip6; |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 84 | u8 as_u8[16]; |
Damjan Marion | 1a64ab9 | 2016-04-29 14:51:57 +0200 | [diff] [blame] | 85 | u64 as_u64[2]; |
Pierre Pfister | 1dabaaf | 2016-04-25 14:15:15 +0100 | [diff] [blame] | 86 | }) ip46_address_t; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 87 | /* *INDENT-ON* */ |
Damjan Marion | 1a64ab9 | 2016-04-29 14:51:57 +0200 | [diff] [blame] | 88 | #define ip46_address_is_ip4(ip46) (((ip46)->pad[0] | (ip46)->pad[1] | (ip46)->pad[2]) == 0) |
| 89 | #define ip46_address_mask_ip4(ip46) ((ip46)->pad[0] = (ip46)->pad[1] = (ip46)->pad[2] = 0) |
| 90 | #define ip46_address_set_ip4(ip46, ip) (ip46_address_mask_ip4(ip46), (ip46)->ip4 = (ip)[0]) |
| 91 | #define ip46_address_reset(ip46) ((ip46)->as_u64[0] = (ip46)->as_u64[1] = 0) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 92 | #define ip46_address_cmp(ip46_1, ip46_2) (memcmp(ip46_1, ip46_2, sizeof(*ip46_1))) |
| 93 | #define ip46_address_is_zero(ip46) (((ip46)->as_u64[0] == 0) && ((ip46)->as_u64[1] == 0)) |
Neale Ranns | 3466c30 | 2017-02-16 07:45:03 -0800 | [diff] [blame] | 94 | #define ip46_address_is_equal(a1, a2) (((a1)->as_u64[0] == (a2)->as_u64[0]) \ |
| 95 | && ((a1)->as_u64[1] == (a2)->as_u64[1])) |
Neale Ranns | 0bdd319 | 2018-09-07 11:04:52 -0700 | [diff] [blame] | 96 | #define ip46_address_initializer {{{ 0 }}} |
| 97 | |
Neale Ranns | c87b66c | 2019-02-07 07:26:12 -0800 | [diff] [blame] | 98 | static_always_inline int |
| 99 | ip46_address_is_equal_v4 (const ip46_address_t * ip46, |
| 100 | const ip4_address_t * ip4) |
| 101 | { |
| 102 | return (ip46->ip4.as_u32 == ip4->as_u32); |
| 103 | } |
| 104 | |
| 105 | static_always_inline int |
| 106 | ip46_address_is_equal_v6 (const ip46_address_t * ip46, |
| 107 | const ip6_address_t * ip6) |
| 108 | { |
| 109 | return ((ip46->ip6.as_u64[0] == ip6->as_u64[0]) && |
| 110 | (ip46->ip6.as_u64[1] == ip6->as_u64[1])); |
| 111 | } |
| 112 | |
Neale Ranns | c0a9314 | 2018-09-05 15:42:26 -0700 | [diff] [blame] | 113 | static_always_inline void |
| 114 | ip46_address_copy (ip46_address_t * dst, const ip46_address_t * src) |
| 115 | { |
| 116 | dst->as_u64[0] = src->as_u64[0]; |
| 117 | dst->as_u64[1] = src->as_u64[1]; |
| 118 | } |
| 119 | |
Neale Ranns | 0bdd319 | 2018-09-07 11:04:52 -0700 | [diff] [blame] | 120 | static_always_inline void |
| 121 | ip46_address_set_ip6 (ip46_address_t * dst, const ip6_address_t * src) |
| 122 | { |
| 123 | dst->as_u64[0] = src->as_u64[0]; |
| 124 | dst->as_u64[1] = src->as_u64[1]; |
| 125 | } |
Pierre Pfister | 1dabaaf | 2016-04-25 14:15:15 +0100 | [diff] [blame] | 126 | |
Eyal Bari | e101e1f | 2017-03-15 08:23:42 +0200 | [diff] [blame] | 127 | always_inline ip46_address_t |
| 128 | to_ip46 (u32 is_ipv6, u8 * buf) |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 129 | { |
Eyal Bari | e101e1f | 2017-03-15 08:23:42 +0200 | [diff] [blame] | 130 | ip46_address_t ip; |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 131 | if (is_ipv6) |
Eyal Bari | e101e1f | 2017-03-15 08:23:42 +0200 | [diff] [blame] | 132 | ip.ip6 = *((ip6_address_t *) buf); |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 133 | else |
Eyal Bari | e101e1f | 2017-03-15 08:23:42 +0200 | [diff] [blame] | 134 | ip46_address_set_ip4 (&ip, (ip4_address_t *) buf); |
| 135 | return ip; |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 136 | } |
| 137 | |
Eyal Bari | e101e1f | 2017-03-15 08:23:42 +0200 | [diff] [blame] | 138 | |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 139 | always_inline void |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 140 | ip6_addr_fib_init (ip6_address_fib_t * addr_fib, |
| 141 | const ip6_address_t * address, u32 fib_index) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 142 | { |
Eyal Bari | e101e1f | 2017-03-15 08:23:42 +0200 | [diff] [blame] | 143 | addr_fib->ip6_addr = *address; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 144 | addr_fib->fib_index = fib_index; |
| 145 | } |
| 146 | |
| 147 | /* Special addresses: |
| 148 | unspecified ::/128 |
| 149 | loopback ::1/128 |
| 150 | global unicast 2000::/3 |
| 151 | unique local unicast fc00::/7 |
| 152 | link local unicast fe80::/10 |
| 153 | multicast ff00::/8 |
| 154 | ietf reserved everything else. */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 155 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 156 | #define foreach_ip6_multicast_address_scope \ |
| 157 | _ (loopback, 0x1) \ |
| 158 | _ (link_local, 0x2) \ |
| 159 | _ (admin_local, 0x4) \ |
| 160 | _ (site_local, 0x5) \ |
| 161 | _ (organization_local, 0x8) \ |
| 162 | _ (global, 0xe) |
| 163 | |
| 164 | #define foreach_ip6_multicast_link_local_group_id \ |
| 165 | _ (all_hosts, 0x1) \ |
| 166 | _ (all_routers, 0x2) \ |
| 167 | _ (rip_routers, 0x9) \ |
| 168 | _ (eigrp_routers, 0xa) \ |
| 169 | _ (pim_routers, 0xd) \ |
| 170 | _ (mldv2_routers, 0x16) |
| 171 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 172 | typedef enum |
| 173 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 174 | #define _(f,n) IP6_MULTICAST_SCOPE_##f = n, |
| 175 | foreach_ip6_multicast_address_scope |
| 176 | #undef _ |
| 177 | } ip6_multicast_address_scope_t; |
| 178 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 179 | typedef enum |
| 180 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 181 | #define _(f,n) IP6_MULTICAST_GROUP_ID_##f = n, |
| 182 | foreach_ip6_multicast_link_local_group_id |
| 183 | #undef _ |
| 184 | } ip6_multicast_link_local_group_id_t; |
| 185 | |
| 186 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 187 | ip6_address_is_multicast (const ip6_address_t * a) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 188 | { |
| 189 | return a->as_u8[0] == 0xff; |
| 190 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 191 | |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 192 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 193 | ip46_address_is_multicast (const ip46_address_t * a) |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 194 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 195 | return ip46_address_is_ip4 (a) ? ip4_address_is_multicast (&a->ip4) : |
| 196 | ip6_address_is_multicast (&a->ip6); |
Eyal Bari | c5b1360 | 2016-11-24 19:42:43 +0200 | [diff] [blame] | 197 | } |
| 198 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 199 | always_inline void |
Neale Ranns | 3702930 | 2018-08-10 05:30:06 -0700 | [diff] [blame] | 200 | ip6_address_copy (ip6_address_t * dst, const ip6_address_t * src) |
| 201 | { |
| 202 | dst->as_u64[0] = src->as_u64[0]; |
| 203 | dst->as_u64[1] = src->as_u64[1]; |
| 204 | } |
| 205 | |
| 206 | always_inline void |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 207 | ip6_set_reserved_multicast_address (ip6_address_t * a, |
| 208 | ip6_multicast_address_scope_t scope, |
| 209 | u16 id) |
| 210 | { |
| 211 | a->as_u64[0] = a->as_u64[1] = 0; |
| 212 | a->as_u16[0] = clib_host_to_net_u16 (0xff00 | scope); |
| 213 | a->as_u16[7] = clib_host_to_net_u16 (id); |
| 214 | } |
| 215 | |
| 216 | always_inline void |
| 217 | ip6_set_solicited_node_multicast_address (ip6_address_t * a, u32 id) |
| 218 | { |
| 219 | /* 0xff02::1:ffXX:XXXX. */ |
| 220 | a->as_u64[0] = a->as_u64[1] = 0; |
| 221 | a->as_u16[0] = clib_host_to_net_u16 (0xff02); |
| 222 | a->as_u8[11] = 1; |
| 223 | ASSERT ((id >> 24) == 0); |
| 224 | id |= 0xff << 24; |
| 225 | a->as_u32[3] = clib_host_to_net_u32 (id); |
| 226 | } |
| 227 | |
| 228 | always_inline void |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 229 | ip6_multicast_ethernet_address (u8 * ethernet_address, u32 group_id) |
| 230 | { |
| 231 | ethernet_address[0] = 0x33; |
| 232 | ethernet_address[1] = 0x33; |
| 233 | ethernet_address[2] = ((group_id >> 24) & 0xff); |
| 234 | ethernet_address[3] = ((group_id >> 16) & 0xff); |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 235 | ethernet_address[4] = ((group_id >> 8) & 0xff); |
| 236 | ethernet_address[5] = ((group_id >> 0) & 0xff); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 240 | ip6_address_is_equal (const ip6_address_t * a, const ip6_address_t * b) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 241 | { |
| 242 | int i; |
| 243 | for (i = 0; i < ARRAY_LEN (a->as_uword); i++) |
| 244 | if (a->as_uword[i] != b->as_uword[i]) |
| 245 | return 0; |
| 246 | return 1; |
| 247 | } |
| 248 | |
| 249 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 250 | ip6_address_is_equal_masked (const ip6_address_t * a, |
| 251 | const ip6_address_t * b, |
| 252 | const ip6_address_t * mask) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 253 | { |
| 254 | int i; |
| 255 | for (i = 0; i < ARRAY_LEN (a->as_uword); i++) |
| 256 | { |
| 257 | uword a_masked, b_masked; |
| 258 | a_masked = a->as_uword[i] & mask->as_uword[i]; |
| 259 | b_masked = b->as_uword[i] & mask->as_uword[i]; |
| 260 | |
| 261 | if (a_masked != b_masked) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 262 | return 0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 263 | } |
| 264 | return 1; |
| 265 | } |
| 266 | |
| 267 | always_inline void |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 268 | ip6_address_mask (ip6_address_t * a, const ip6_address_t * mask) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 269 | { |
| 270 | int i; |
| 271 | for (i = 0; i < ARRAY_LEN (a->as_uword); i++) |
| 272 | a->as_uword[i] &= mask->as_uword[i]; |
| 273 | } |
| 274 | |
| 275 | always_inline void |
| 276 | ip6_address_set_zero (ip6_address_t * a) |
| 277 | { |
| 278 | int i; |
| 279 | for (i = 0; i < ARRAY_LEN (a->as_uword); i++) |
| 280 | a->as_uword[i] = 0; |
| 281 | } |
| 282 | |
| 283 | always_inline void |
| 284 | ip6_address_mask_from_width (ip6_address_t * a, u32 width) |
| 285 | { |
| 286 | int i, byte, bit, bitnum; |
| 287 | ASSERT (width <= 128); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 288 | clib_memset (a, 0, sizeof (a[0])); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 289 | for (i = 0; i < width; i++) |
| 290 | { |
| 291 | bitnum = (7 - (i & 7)); |
| 292 | byte = i / 8; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 293 | bit = 1 << bitnum; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 294 | a->as_u8[byte] |= bit; |
| 295 | } |
| 296 | } |
| 297 | |
| 298 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 299 | ip6_address_is_zero (const ip6_address_t * a) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 300 | { |
| 301 | int i; |
| 302 | for (i = 0; i < ARRAY_LEN (a->as_uword); i++) |
| 303 | if (a->as_uword[i] != 0) |
| 304 | return 0; |
| 305 | return 1; |
| 306 | } |
| 307 | |
| 308 | /* Check for unspecified address ::0 */ |
| 309 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 310 | ip6_address_is_unspecified (const ip6_address_t * a) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 311 | { |
| 312 | return ip6_address_is_zero (a); |
| 313 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 314 | |
| 315 | /* Check for loopback address ::1 */ |
| 316 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 317 | ip6_address_is_loopback (const ip6_address_t * a) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 318 | { |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 319 | return (a->as_u64[0] == 0 && |
| 320 | a->as_u32[2] == 0 && |
| 321 | a->as_u16[6] == 0 && a->as_u8[14] == 0 && a->as_u8[15] == 1); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 322 | } |
| 323 | |
| 324 | /* Check for link local unicast fe80::/10. */ |
| 325 | always_inline uword |
Neale Ranns | 53da221 | 2018-02-24 02:11:19 -0800 | [diff] [blame] | 326 | ip6_address_is_link_local_unicast (const ip6_address_t * a) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 327 | { |
| 328 | return a->as_u8[0] == 0xfe && (a->as_u8[1] & 0xc0) == 0x80; |
| 329 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 330 | |
| 331 | /* Check for unique local unicast fc00::/7. */ |
| 332 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 333 | ip6_address_is_local_unicast (const ip6_address_t * a) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 334 | { |
| 335 | return (a->as_u8[0] & 0xfe) == 0xfc; |
| 336 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 337 | |
Chris Luke | bfd32fd | 2016-06-24 20:38:06 -0400 | [diff] [blame] | 338 | /* Check for unique global unicast 2000::/3. */ |
| 339 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 340 | ip6_address_is_global_unicast (const ip6_address_t * a) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 341 | { |
| 342 | return (a->as_u8[0] & 0xe0) == 0x20; |
| 343 | } |
Chris Luke | bfd32fd | 2016-06-24 20:38:06 -0400 | [diff] [blame] | 344 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 345 | /* Check for solicited node multicast 0xff02::1:ff00:0/104 */ |
| 346 | always_inline uword |
Neale Ranns | d69f439 | 2018-08-31 06:30:16 -0400 | [diff] [blame] | 347 | ip6_is_solicited_node_multicast_address (const ip6_address_t * a) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 348 | { |
| 349 | return (a->as_u32[0] == clib_host_to_net_u32 (0xff020000) |
| 350 | && a->as_u32[1] == 0 |
| 351 | && a->as_u32[2] == clib_host_to_net_u32 (1) |
| 352 | && a->as_u8[12] == 0xff); |
| 353 | } |
| 354 | |
Neale Ranns | cd35e53 | 2018-08-31 02:51:45 -0700 | [diff] [blame] | 355 | always_inline u32 |
| 356 | ip6_address_hash_to_u32 (const ip6_address_t * a) |
| 357 | { |
| 358 | return (a->as_u32[0] ^ a->as_u32[1] ^ a->as_u32[2] ^ a->as_u32[3]); |
| 359 | } |
| 360 | |
| 361 | always_inline u64 |
| 362 | ip6_address_hash_to_u64 (const ip6_address_t * a) |
| 363 | { |
| 364 | return (a->as_u64[0] ^ a->as_u64[1]); |
| 365 | } |
| 366 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 367 | typedef struct |
| 368 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 369 | /* 4 bit version, 8 bit traffic class and 20 bit flow label. */ |
| 370 | u32 ip_version_traffic_class_and_flow_label; |
| 371 | |
| 372 | /* Total packet length not including this header (but including |
| 373 | any extension headers if present). */ |
| 374 | u16 payload_length; |
| 375 | |
| 376 | /* Protocol for next header. */ |
| 377 | u8 protocol; |
| 378 | |
| 379 | /* Hop limit decremented by router at each hop. */ |
| 380 | u8 hop_limit; |
| 381 | |
| 382 | /* Source and destination address. */ |
| 383 | ip6_address_t src_address, dst_address; |
| 384 | } ip6_header_t; |
| 385 | |
Neale Ranns | 038e1df | 2019-07-19 14:01:02 +0000 | [diff] [blame] | 386 | always_inline ip_dscp_t |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 387 | ip6_traffic_class (const ip6_header_t * i) |
Ole Troan | 5c74973 | 2017-03-13 13:39:52 +0100 | [diff] [blame] | 388 | { |
| 389 | return (i->ip_version_traffic_class_and_flow_label & 0x0FF00000) >> 20; |
| 390 | } |
| 391 | |
Neale Ranns | 038e1df | 2019-07-19 14:01:02 +0000 | [diff] [blame] | 392 | static_always_inline ip_dscp_t |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 393 | ip6_traffic_class_network_order (const ip6_header_t * ip6) |
| 394 | { |
| 395 | return (clib_net_to_host_u32 (ip6->ip_version_traffic_class_and_flow_label) |
| 396 | & 0x0ff00000) >> 20; |
| 397 | } |
| 398 | |
| 399 | static_always_inline void |
Neale Ranns | 038e1df | 2019-07-19 14:01:02 +0000 | [diff] [blame] | 400 | ip6_set_traffic_class_network_order (ip6_header_t * ip6, ip_dscp_t dscp) |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 401 | { |
| 402 | u32 tmp = |
| 403 | clib_net_to_host_u32 (ip6->ip_version_traffic_class_and_flow_label); |
Neale Ranns | 039cbfe | 2018-02-27 03:45:38 -0800 | [diff] [blame] | 404 | tmp &= 0xf00fffff; |
Neale Ranns | 31ed744 | 2018-02-23 05:29:09 -0800 | [diff] [blame] | 405 | tmp |= (dscp << 20); |
| 406 | ip6->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32 (tmp); |
| 407 | } |
| 408 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 409 | always_inline void * |
| 410 | ip6_next_header (ip6_header_t * i) |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 411 | { |
| 412 | return (void *) (i + 1); |
| 413 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 414 | |
| 415 | always_inline void |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 416 | ip6_copy_header (ip6_header_t * dst, const ip6_header_t * src) |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 417 | { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 418 | dst->ip_version_traffic_class_and_flow_label = |
| 419 | src->ip_version_traffic_class_and_flow_label; |
| 420 | dst->payload_length = src->payload_length; |
| 421 | dst->protocol = src->protocol; |
| 422 | dst->hop_limit = src->hop_limit; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 423 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 424 | dst->src_address.as_uword[0] = src->src_address.as_uword[0]; |
| 425 | dst->src_address.as_uword[1] = src->src_address.as_uword[1]; |
| 426 | dst->dst_address.as_uword[0] = src->dst_address.as_uword[0]; |
| 427 | dst->dst_address.as_uword[1] = src->dst_address.as_uword[1]; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 428 | } |
| 429 | |
| 430 | always_inline void |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 431 | ip6_tcp_reply_x1 (ip6_header_t * ip0, tcp_header_t * tcp0) |
| 432 | { |
| 433 | { |
| 434 | ip6_address_t src0, dst0; |
| 435 | |
| 436 | src0 = ip0->src_address; |
| 437 | dst0 = ip0->dst_address; |
| 438 | ip0->src_address = dst0; |
| 439 | ip0->dst_address = src0; |
| 440 | } |
| 441 | |
| 442 | { |
| 443 | u16 src0, dst0; |
| 444 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 445 | src0 = tcp0->src; |
| 446 | dst0 = tcp0->dst; |
| 447 | tcp0->src = dst0; |
| 448 | tcp0->dst = src0; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 449 | } |
| 450 | } |
| 451 | |
| 452 | always_inline void |
| 453 | ip6_tcp_reply_x2 (ip6_header_t * ip0, ip6_header_t * ip1, |
| 454 | tcp_header_t * tcp0, tcp_header_t * tcp1) |
| 455 | { |
| 456 | { |
| 457 | ip6_address_t src0, dst0, src1, dst1; |
| 458 | |
| 459 | src0 = ip0->src_address; |
| 460 | src1 = ip1->src_address; |
| 461 | dst0 = ip0->dst_address; |
| 462 | dst1 = ip1->dst_address; |
| 463 | ip0->src_address = dst0; |
| 464 | ip1->src_address = dst1; |
| 465 | ip0->dst_address = src0; |
| 466 | ip1->dst_address = src1; |
| 467 | } |
| 468 | |
| 469 | { |
| 470 | u16 src0, dst0, src1, dst1; |
| 471 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 472 | src0 = tcp0->src; |
| 473 | src1 = tcp1->src; |
| 474 | dst0 = tcp0->dst; |
| 475 | dst1 = tcp1->dst; |
| 476 | tcp0->src = dst0; |
| 477 | tcp1->src = dst1; |
| 478 | tcp0->dst = src0; |
| 479 | tcp1->dst = src1; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 480 | } |
| 481 | } |
| 482 | |
| 483 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 484 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 485 | typedef CLIB_PACKED (struct { |
| 486 | u8 data; |
| 487 | }) ip6_pad1_option_t; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 488 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 489 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 490 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 491 | typedef CLIB_PACKED (struct { |
| 492 | u8 type; |
| 493 | u8 len; |
| 494 | u8 data[0]; |
| 495 | }) ip6_padN_option_t; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 496 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 497 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 498 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 499 | typedef CLIB_PACKED (struct { |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 500 | #define IP6_MLDP_ALERT_TYPE 0x5 |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 501 | u8 type; |
| 502 | u8 len; |
| 503 | u16 value; |
| 504 | }) ip6_router_alert_option_t; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 505 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 506 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 507 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 508 | typedef CLIB_PACKED (struct { |
| 509 | u8 next_hdr; |
| 510 | /* Length of this header plus option data in 8 byte units. */ |
| 511 | u8 n_data_u64s; |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 512 | }) ip6_ext_header_t; |
| 513 | |
Damjan Marion | 831d238 | 2019-03-22 13:58:08 +0100 | [diff] [blame] | 514 | #define foreach_ext_hdr_type \ |
| 515 | _(IP6_HOP_BY_HOP_OPTIONS) \ |
| 516 | _(IPV6_ROUTE) \ |
| 517 | _(IPV6_FRAGMENTATION) \ |
| 518 | _(IPSEC_ESP) \ |
| 519 | _(IPSEC_AH) \ |
| 520 | _(IP6_DESTINATION_OPTIONS) \ |
| 521 | _(MOBILITY) \ |
| 522 | _(HIP) \ |
| 523 | _(SHIM6) |
| 524 | |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 525 | always_inline u8 ip6_ext_hdr(u8 nexthdr) |
| 526 | { |
Damjan Marion | 831d238 | 2019-03-22 13:58:08 +0100 | [diff] [blame] | 527 | #ifdef CLIB_HAVE_VEC128 |
| 528 | static const u8x16 ext_hdr_types = { |
| 529 | #define _(x) IP_PROTOCOL_##x, |
| 530 | foreach_ext_hdr_type |
| 531 | #undef _ |
| 532 | }; |
| 533 | |
| 534 | return !u8x16_is_all_zero (ext_hdr_types == u8x16_splat (nexthdr)); |
| 535 | #else |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 536 | /* |
| 537 | * find out if nexthdr is an extension header or a protocol |
| 538 | */ |
Damjan Marion | 831d238 | 2019-03-22 13:58:08 +0100 | [diff] [blame] | 539 | return 0 |
| 540 | #define _(x) || (nexthdr == IP_PROTOCOL_##x) |
| 541 | foreach_ext_hdr_type; |
| 542 | #undef _ |
| 543 | #endif |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 544 | } |
| 545 | |
Pablo Camarillo | fb38095 | 2016-12-07 18:34:18 +0100 | [diff] [blame] | 546 | #define ip6_ext_header_len(p) ((((ip6_ext_header_t *)(p))->n_data_u64s+1) << 3) |
| 547 | #define ip6_ext_authhdr_len(p) ((((ip6_ext_header_t *)(p))->n_data_u64s+2) << 2) |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 548 | |
| 549 | always_inline void * |
| 550 | ip6_ext_next_header (ip6_ext_header_t *ext_hdr ) |
| 551 | { return (void *)((u8 *) ext_hdr + ip6_ext_header_len(ext_hdr)); } |
| 552 | |
Pablo Camarillo | fb38095 | 2016-12-07 18:34:18 +0100 | [diff] [blame] | 553 | /* |
| 554 | * Macro to find the IPv6 ext header of type t |
| 555 | * I is the IPv6 header |
| 556 | * P is the previous IPv6 ext header (NULL if none) |
| 557 | * M is the matched IPv6 ext header of type t |
| 558 | */ |
| 559 | #define ip6_ext_header_find_t(i, p, m, t) \ |
| 560 | if ((i)->protocol == t) \ |
| 561 | { \ |
| 562 | (m) = (void *)((i)+1); \ |
| 563 | (p) = NULL; \ |
| 564 | } \ |
| 565 | else \ |
| 566 | { \ |
| 567 | (m) = NULL; \ |
| 568 | (p) = (void *)((i)+1); \ |
| 569 | while (ip6_ext_hdr((p)->next_hdr) && \ |
| 570 | ((ip6_ext_header_t *)(p))->next_hdr != (t)) \ |
| 571 | { \ |
| 572 | (p) = ip6_ext_next_header((p)); \ |
| 573 | } \ |
shwethab | e146f13 | 2017-03-09 16:58:26 +0000 | [diff] [blame] | 574 | if ( ((p)->next_hdr) == (t)) \ |
Pablo Camarillo | fb38095 | 2016-12-07 18:34:18 +0100 | [diff] [blame] | 575 | { \ |
| 576 | (m) = (void *)(ip6_ext_next_header((p))); \ |
| 577 | } \ |
| 578 | } |
| 579 | |
| 580 | |
Shwetha | b78292e | 2016-09-13 11:51:00 +0100 | [diff] [blame] | 581 | typedef CLIB_PACKED (struct { |
| 582 | u8 next_hdr; |
| 583 | /* Length of this header plus option data in 8 byte units. */ |
| 584 | u8 n_data_u64s; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 585 | u8 data[0]; |
| 586 | }) ip6_hop_by_hop_ext_t; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 587 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 588 | |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 589 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 590 | typedef CLIB_PACKED (struct { |
| 591 | u8 next_hdr; |
| 592 | u8 rsv; |
| 593 | u16 fragment_offset_and_more; |
| 594 | u32 identification; |
| 595 | }) ip6_frag_hdr_t; |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 596 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 597 | |
| 598 | #define ip6_frag_hdr_offset(hdr) \ |
| 599 | (clib_net_to_host_u16((hdr)->fragment_offset_and_more) >> 3) |
| 600 | |
Klement Sekera | 75e7d13 | 2017-09-20 08:26:30 +0200 | [diff] [blame] | 601 | #define ip6_frag_hdr_offset_bytes(hdr) \ |
| 602 | (8 * ip6_frag_hdr_offset(hdr)) |
| 603 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 604 | #define ip6_frag_hdr_more(hdr) \ |
| 605 | (clib_net_to_host_u16((hdr)->fragment_offset_and_more) & 0x1) |
| 606 | |
| 607 | #define ip6_frag_hdr_offset_and_more(offset, more) \ |
| 608 | clib_host_to_net_u16(((offset) << 3) + !!(more)) |
| 609 | |
| 610 | #endif /* included_ip6_packet_h */ |
Dave Barach | d7cb1b5 | 2016-12-09 09:52:16 -0500 | [diff] [blame] | 611 | |
| 612 | /* |
| 613 | * fd.io coding-style-patch-verification: ON |
| 614 | * |
| 615 | * Local Variables: |
| 616 | * eval: (c-set-style "gnu") |
| 617 | * End: |
| 618 | */ |