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 | #include <stdbool.h> |
| 16 | #include <vppinfra/error.h> |
| 17 | #include <vnet/vnet.h> |
| 18 | #include <vnet/ip/ip.h> |
| 19 | #include <vlib/vlib.h> |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 20 | #include <vnet/fib/fib_types.h> |
| 21 | #include <vnet/fib/ip4_fib.h> |
| 22 | #include <vnet/adj/adj.h> |
| 23 | #include <vnet/map/map_dpo.h> |
| 24 | #include <vnet/dpo/load_balance.h> |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 25 | |
| 26 | #define MAP_SKIP_IP6_LOOKUP 1 |
| 27 | |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 28 | typedef enum |
| 29 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 30 | MAP_SENDER, |
| 31 | MAP_RECEIVER |
| 32 | } map_dir_e; |
| 33 | |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 34 | int map_create_domain (ip4_address_t * ip4_prefix, u8 ip4_prefix_len, |
| 35 | ip6_address_t * ip6_prefix, u8 ip6_prefix_len, |
| 36 | ip6_address_t * ip6_src, u8 ip6_src_len, |
| 37 | u8 ea_bits_len, u8 psid_offset, u8 psid_length, |
| 38 | u32 * map_domain_index, u16 mtu, u8 flags); |
| 39 | int map_delete_domain (u32 map_domain_index); |
| 40 | int map_add_del_psid (u32 map_domain_index, u16 psid, ip6_address_t * tep, |
| 41 | u8 is_add); |
| 42 | u8 *format_map_trace (u8 * s, va_list * args); |
| 43 | i32 ip4_get_port (ip4_header_t * ip, map_dir_e dir, u16 buffer_len); |
| 44 | i32 ip6_get_port (ip6_header_t * ip6, map_dir_e dir, u16 buffer_len); |
| 45 | u16 ip4_map_get_port (ip4_header_t * ip, map_dir_e dir); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 46 | |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 47 | typedef enum __attribute__ ((__packed__)) |
| 48 | { |
| 49 | MAP_DOMAIN_PREFIX = 1 << 0, MAP_DOMAIN_TRANSLATION = 1 << 1, // The domain uses MAP-T |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 50 | } map_domain_flags_e; |
| 51 | |
| 52 | /** |
| 53 | * IP4 reassembly logic: |
| 54 | * One virtually reassembled flow requires a map_ip4_reass_t structure in order |
| 55 | * to keep the first-fragment port number and, optionally, cache out of sequence |
| 56 | * packets. |
| 57 | * There are up to MAP_IP4_REASS_MAX_REASSEMBLY such structures. |
| 58 | * When in use, those structures are stored in a hash table of MAP_IP4_REASS_BUCKETS buckets. |
| 59 | * When a new structure needs to be used, it is allocated from available ones. |
| 60 | * If there is no structure available, the oldest in use is selected and used if and |
| 61 | * only if it was first allocated more than MAP_IP4_REASS_LIFETIME seconds ago. |
| 62 | * In case no structure can be allocated, the fragment is dropped. |
| 63 | */ |
| 64 | |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 65 | #define MAP_IP4_REASS_LIFETIME_DEFAULT (100) /* ms */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 66 | #define MAP_IP4_REASS_HT_RATIO_DEFAULT (1.0) |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 67 | #define MAP_IP4_REASS_POOL_SIZE_DEFAULT 1024 // Number of reassembly structures |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 68 | #define MAP_IP4_REASS_BUFFERS_DEFAULT 2048 |
| 69 | |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 70 | #define MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY 5 // Number of fragment per reassembly |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 71 | |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 72 | #define MAP_IP6_REASS_LIFETIME_DEFAULT (100) /* ms */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 73 | #define MAP_IP6_REASS_HT_RATIO_DEFAULT (1.0) |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 74 | #define MAP_IP6_REASS_POOL_SIZE_DEFAULT 1024 // Number of reassembly structures |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 75 | #define MAP_IP6_REASS_BUFFERS_DEFAULT 2048 |
| 76 | |
| 77 | #define MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY 5 |
| 78 | |
| 79 | #define MAP_IP6_REASS_COUNT_BYTES |
| 80 | #define MAP_IP4_REASS_COUNT_BYTES |
| 81 | |
| 82 | //#define IP6_MAP_T_OVERRIDE_TOS 0 |
| 83 | |
| 84 | /* |
| 85 | * This structure _MUST_ be no larger than a single cache line (64 bytes). |
| 86 | * If more space is needed make a union of ip6_prefix and *rules, those are mutually exclusive. |
| 87 | */ |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 88 | typedef struct |
| 89 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 90 | ip6_address_t ip6_src; |
| 91 | ip6_address_t ip6_prefix; |
| 92 | ip6_address_t *rules; |
| 93 | u32 suffix_mask; |
| 94 | ip4_address_t ip4_prefix; |
| 95 | u16 psid_mask; |
| 96 | u16 mtu; |
| 97 | map_domain_flags_e flags; |
| 98 | u8 ip6_prefix_len; |
| 99 | u8 ip6_src_len; |
| 100 | u8 ea_bits_len; |
| 101 | u8 psid_offset; |
| 102 | u8 psid_length; |
| 103 | |
| 104 | /* helpers */ |
| 105 | u8 psid_shift; |
| 106 | u8 suffix_shift; |
| 107 | u8 ea_shift; |
| 108 | |
| 109 | /* not used by forwarding */ |
| 110 | u8 ip4_prefix_len; |
| 111 | } map_domain_t; |
| 112 | |
Damjan Marion | cf47894 | 2016-11-07 14:57:50 +0100 | [diff] [blame] | 113 | STATIC_ASSERT ((sizeof (map_domain_t) <= CLIB_CACHE_LINE_BYTES), |
| 114 | "MAP domain fits in one cacheline"); |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 115 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 116 | #define MAP_REASS_INDEX_NONE ((u16)0xffff) |
| 117 | |
| 118 | /* |
| 119 | * Hash key, padded out to 16 bytes for fast compare |
| 120 | */ |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 121 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 122 | typedef union { |
| 123 | CLIB_PACKED (struct { |
| 124 | ip4_address_t src; |
| 125 | ip4_address_t dst; |
| 126 | u16 fragment_id; |
| 127 | u8 protocol; |
| 128 | }); |
| 129 | u64 as_u64[2]; |
| 130 | u32 as_u32[4]; |
| 131 | } map_ip4_reass_key_t; |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 132 | /* *INDENT-ON* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 133 | |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 134 | typedef struct |
| 135 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 136 | map_ip4_reass_key_t key; |
| 137 | f64 ts; |
| 138 | #ifdef MAP_IP4_REASS_COUNT_BYTES |
| 139 | u16 expected_total; |
| 140 | u16 forwarded; |
| 141 | #endif |
| 142 | i32 port; |
| 143 | u16 bucket; |
| 144 | u16 bucket_next; |
| 145 | u16 fifo_prev; |
| 146 | u16 fifo_next; |
| 147 | u32 fragments[MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY]; |
| 148 | } map_ip4_reass_t; |
| 149 | |
| 150 | /* |
| 151 | * MAP domain counters |
| 152 | */ |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 153 | typedef enum |
| 154 | { |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 155 | /* Simple counters */ |
| 156 | MAP_DOMAIN_IPV4_FRAGMENT = 0, |
| 157 | /* Combined counters */ |
| 158 | MAP_DOMAIN_COUNTER_RX = 0, |
| 159 | MAP_DOMAIN_COUNTER_TX, |
| 160 | MAP_N_DOMAIN_COUNTER |
| 161 | } map_domain_counter_t; |
| 162 | |
| 163 | /* |
| 164 | * main_main_t |
| 165 | */ |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 166 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 167 | typedef union { |
| 168 | CLIB_PACKED (struct { |
| 169 | ip6_address_t src; |
| 170 | ip6_address_t dst; |
| 171 | u32 fragment_id; |
| 172 | u8 protocol; |
| 173 | }); |
| 174 | u64 as_u64[5]; |
| 175 | u32 as_u32[10]; |
| 176 | } map_ip6_reass_key_t; |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 177 | /* *INDENT-OFF* */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 178 | |
| 179 | typedef struct { |
| 180 | u32 pi; //Cached packet or ~0 |
| 181 | u16 next_data_offset; //The data offset of the additional 20 bytes or ~0 |
| 182 | u8 next_data_len; //Number of bytes ready to be copied (20 if not last fragment) |
| 183 | u8 next_data[20]; //The 20 additional bytes |
| 184 | } map_ip6_fragment_t; |
| 185 | |
| 186 | typedef struct { |
| 187 | map_ip6_reass_key_t key; |
| 188 | f64 ts; |
| 189 | #ifdef MAP_IP6_REASS_COUNT_BYTES |
| 190 | u16 expected_total; |
| 191 | u16 forwarded; |
| 192 | #endif |
| 193 | u16 bucket; //What hash bucket this element is linked in |
| 194 | u16 bucket_next; |
| 195 | u16 fifo_prev; |
| 196 | u16 fifo_next; |
| 197 | ip4_header_t ip4_header; |
| 198 | map_ip6_fragment_t fragments[MAP_IP6_REASS_MAX_FRAGMENTS_PER_REASSEMBLY]; |
| 199 | } map_ip6_reass_t; |
| 200 | |
Neale Ranns | 8082380 | 2017-02-20 18:23:41 -0800 | [diff] [blame] | 201 | #ifdef MAP_SKIP_IP6_LOOKUP |
| 202 | /** |
| 203 | * A pre-resolved next-hop |
| 204 | */ |
| 205 | typedef struct map_main_pre_resolved_t_ |
| 206 | { |
| 207 | /** |
| 208 | * Linkage into the FIB graph |
| 209 | */ |
| 210 | fib_node_t node; |
| 211 | |
| 212 | /** |
| 213 | * The FIB entry index of the next-hop |
| 214 | */ |
| 215 | fib_node_index_t fei; |
| 216 | |
| 217 | /** |
| 218 | * This object sibling index on the FIB entry's child dependency list |
| 219 | */ |
| 220 | u32 sibling; |
| 221 | |
| 222 | /** |
| 223 | * The Load-balance object index to use to forward |
| 224 | */ |
| 225 | dpo_id_t dpo; |
| 226 | } map_main_pre_resolved_t; |
| 227 | |
| 228 | /** |
| 229 | * Pre-resolved next hops for v4 and v6. Why these are global and not |
| 230 | * per-domain is beyond me. |
| 231 | */ |
| 232 | extern map_main_pre_resolved_t pre_resolved[FIB_PROTOCOL_MAX]; |
| 233 | #endif |
| 234 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 235 | typedef struct { |
| 236 | /* pool of MAP domains */ |
| 237 | map_domain_t *domains; |
| 238 | |
| 239 | /* MAP Domain packet/byte counters indexed by map domain index */ |
| 240 | vlib_simple_counter_main_t *simple_domain_counters; |
| 241 | vlib_combined_counter_main_t *domain_counters; |
| 242 | volatile u32 *counter_lock; |
| 243 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 244 | /* Traffic class: zero, copy (~0) or fixed value */ |
| 245 | u8 tc; |
| 246 | bool tc_copy; |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 247 | |
| 248 | bool sec_check; /* Inbound security check */ |
| 249 | bool sec_check_frag; /* Inbound security check for (subsequent) fragments */ |
| 250 | bool icmp6_enabled; /* Send destination unreachable for security check failure */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 251 | |
| 252 | /* ICMPv6 -> ICMPv4 relay parameters */ |
Ole Troan | cda9482 | 2016-01-07 14:37:25 +0100 | [diff] [blame] | 253 | ip4_address_t icmp4_src_address; |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 254 | vlib_simple_counter_main_t icmp_relayed; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 255 | |
| 256 | /* convenience */ |
| 257 | vlib_main_t *vlib_main; |
| 258 | vnet_main_t *vnet_main; |
| 259 | |
| 260 | /* |
| 261 | * IPv4 encap and decap reassembly |
| 262 | */ |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 263 | /* Configuration */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 264 | f32 ip4_reass_conf_ht_ratio; //Size of ht is 2^ceil(log2(ratio*pool_size)) |
| 265 | u16 ip4_reass_conf_pool_size; //Max number of allocated reass structures |
| 266 | u16 ip4_reass_conf_lifetime_ms; //Time a reassembly struct is considered valid in ms |
| 267 | u32 ip4_reass_conf_buffers; //Maximum number of buffers used by ip4 reassembly |
| 268 | |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 269 | /* Runtime */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 270 | map_ip4_reass_t *ip4_reass_pool; |
| 271 | u8 ip4_reass_ht_log2len; //Hash table size is 2^log2len |
| 272 | u16 ip4_reass_allocated; |
| 273 | u16 *ip4_reass_hash_table; |
| 274 | u16 ip4_reass_fifo_last; |
| 275 | volatile u32 *ip4_reass_lock; |
| 276 | |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 277 | /* Counters */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 278 | u32 ip4_reass_buffered_counter; |
| 279 | |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 280 | bool frag_inner; /* Inner or outer fragmentation */ |
| 281 | bool frag_ignore_df; /* Fragment (outer) packet even if DF is set */ |
| 282 | |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 283 | /* |
| 284 | * IPv6 decap reassembly |
| 285 | */ |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 286 | /* Configuration */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 287 | f32 ip6_reass_conf_ht_ratio; //Size of ht is 2^ceil(log2(ratio*pool_size)) |
| 288 | u16 ip6_reass_conf_pool_size; //Max number of allocated reass structures |
| 289 | u16 ip6_reass_conf_lifetime_ms; //Time a reassembly struct is considered valid in ms |
| 290 | u32 ip6_reass_conf_buffers; //Maximum number of buffers used by ip6 reassembly |
| 291 | |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 292 | /* Runtime */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 293 | map_ip6_reass_t *ip6_reass_pool; |
| 294 | u8 ip6_reass_ht_log2len; //Hash table size is 2^log2len |
| 295 | u16 ip6_reass_allocated; |
| 296 | u16 *ip6_reass_hash_table; |
| 297 | u16 ip6_reass_fifo_last; |
| 298 | volatile u32 *ip6_reass_lock; |
| 299 | |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 300 | /* Counters */ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 301 | u32 ip6_reass_buffered_counter; |
| 302 | |
| 303 | } map_main_t; |
| 304 | |
| 305 | /* |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 306 | * MAP Error counters/messages |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 307 | */ |
| 308 | #define foreach_map_error \ |
| 309 | /* Must be first. */ \ |
| 310 | _(NONE, "valid MAP packets") \ |
| 311 | _(BAD_PROTOCOL, "bad protocol") \ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 312 | _(SEC_CHECK, "security check failed") \ |
| 313 | _(ENCAP_SEC_CHECK, "encap security check failed") \ |
| 314 | _(DECAP_SEC_CHECK, "decap security check failed") \ |
| 315 | _(ICMP, "unable to translate ICMP") \ |
| 316 | _(ICMP_RELAY, "unable to relay ICMP") \ |
| 317 | _(UNKNOWN, "unknown") \ |
Ole Troan | cda9482 | 2016-01-07 14:37:25 +0100 | [diff] [blame] | 318 | _(NO_BINDING, "no binding") \ |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 319 | _(NO_DOMAIN, "no domain") \ |
| 320 | _(FRAGMENTED, "packet is a fragment") \ |
| 321 | _(FRAGMENT_MEMORY, "could not cache fragment") \ |
| 322 | _(FRAGMENT_MALFORMED, "fragment has unexpected format")\ |
| 323 | _(FRAGMENT_DROPPED, "dropped cached fragment") \ |
Ole Troan | 366ac6e | 2016-01-06 12:40:28 +0100 | [diff] [blame] | 324 | _(MALFORMED, "malformed packet") \ |
Ole Troan | 9fb8755 | 2016-01-13 22:30:43 +0100 | [diff] [blame] | 325 | _(DF_SET, "can't fragment, DF set") |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 326 | |
| 327 | typedef enum { |
| 328 | #define _(sym,str) MAP_ERROR_##sym, |
| 329 | foreach_map_error |
| 330 | #undef _ |
| 331 | MAP_N_ERROR, |
| 332 | } map_error_t; |
| 333 | |
| 334 | u64 map_error_counter_get(u32 node_index, map_error_t map_error); |
| 335 | |
| 336 | typedef struct { |
| 337 | u32 map_domain_index; |
| 338 | u16 port; |
| 339 | } map_trace_t; |
| 340 | |
| 341 | map_main_t map_main; |
| 342 | |
Jean-Mickael Guerin | 8941ec2 | 2016-03-04 14:14:21 +0100 | [diff] [blame] | 343 | extern vlib_node_registration_t ip4_map_node; |
| 344 | extern vlib_node_registration_t ip6_map_node; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 345 | |
Jean-Mickael Guerin | 8941ec2 | 2016-03-04 14:14:21 +0100 | [diff] [blame] | 346 | extern vlib_node_registration_t ip4_map_t_node; |
| 347 | extern vlib_node_registration_t ip4_map_t_fragmented_node; |
| 348 | extern vlib_node_registration_t ip4_map_t_tcp_udp_node; |
| 349 | extern vlib_node_registration_t ip4_map_t_icmp_node; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 350 | |
Jean-Mickael Guerin | 8941ec2 | 2016-03-04 14:14:21 +0100 | [diff] [blame] | 351 | extern vlib_node_registration_t ip6_map_t_node; |
| 352 | extern vlib_node_registration_t ip6_map_t_fragmented_node; |
| 353 | extern vlib_node_registration_t ip6_map_t_tcp_udp_node; |
| 354 | extern vlib_node_registration_t ip6_map_t_icmp_node; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 355 | |
| 356 | /* |
| 357 | * map_get_pfx |
| 358 | */ |
| 359 | static_always_inline u64 |
| 360 | map_get_pfx (map_domain_t *d, u32 addr, u16 port) |
| 361 | { |
| 362 | u16 psid = (port >> d->psid_shift) & d->psid_mask; |
| 363 | |
| 364 | if (d->ea_bits_len == 0 && d->rules) |
| 365 | return clib_net_to_host_u64(d->rules[psid].as_u64[0]); |
| 366 | |
| 367 | u32 suffix = (addr >> d->suffix_shift) & d->suffix_mask; |
| 368 | u64 ea = d->ea_bits_len == 0 ? 0 : (((u64) suffix << d->psid_length)) | psid; |
| 369 | |
| 370 | return clib_net_to_host_u64(d->ip6_prefix.as_u64[0]) | ea << d->ea_shift; |
| 371 | } |
| 372 | |
| 373 | static_always_inline u64 |
| 374 | map_get_pfx_net (map_domain_t *d, u32 addr, u16 port) |
| 375 | { |
| 376 | return clib_host_to_net_u64(map_get_pfx(d, clib_net_to_host_u32(addr), |
| 377 | clib_net_to_host_u16(port))); |
| 378 | } |
| 379 | |
| 380 | /* |
| 381 | * map_get_sfx |
| 382 | */ |
| 383 | static_always_inline u64 |
| 384 | map_get_sfx (map_domain_t *d, u32 addr, u16 port) |
| 385 | { |
| 386 | u16 psid = (port >> d->psid_shift) & d->psid_mask; |
| 387 | |
| 388 | /* Shared 1:1 mode. */ |
| 389 | if (d->ea_bits_len == 0 && d->rules) |
| 390 | return clib_net_to_host_u64(d->rules[psid].as_u64[1]); |
| 391 | if (d->ip6_prefix_len == 128) |
| 392 | return clib_net_to_host_u64(d->ip6_prefix.as_u64[1]); |
| 393 | |
| 394 | /* IPv4 prefix */ |
| 395 | if (d->flags & MAP_DOMAIN_PREFIX) |
Ole Troan | d575e69 | 2016-08-25 12:26:47 +0200 | [diff] [blame] | 396 | return (u64) (addr & (0xFFFFFFFF << d->suffix_shift)) << 16; |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 397 | |
| 398 | /* Shared or full IPv4 address */ |
| 399 | return ((u64) addr << 16) | psid; |
| 400 | } |
| 401 | |
| 402 | static_always_inline u64 |
| 403 | map_get_sfx_net (map_domain_t *d, u32 addr, u16 port) |
| 404 | { |
| 405 | return clib_host_to_net_u64(map_get_sfx(d, clib_net_to_host_u32(addr), |
| 406 | clib_net_to_host_u16(port))); |
| 407 | } |
| 408 | |
| 409 | static_always_inline u32 |
| 410 | map_get_ip4 (ip6_address_t *addr) |
| 411 | { |
| 412 | return clib_host_to_net_u32(clib_net_to_host_u64(addr->as_u64[1]) >> 16); |
| 413 | } |
| 414 | |
| 415 | /* |
| 416 | * Get the MAP domain from an IPv4 lookup adjacency. |
| 417 | */ |
| 418 | static_always_inline map_domain_t * |
Neale Ranns | 9705c38 | 2017-02-20 20:29:41 -0800 | [diff] [blame] | 419 | ip4_map_get_domain (u32 mdi) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 420 | { |
| 421 | map_main_t *mm = &map_main; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 422 | |
Neale Ranns | 9705c38 | 2017-02-20 20:29:41 -0800 | [diff] [blame] | 423 | return pool_elt_at_index(mm->domains, mdi); |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 424 | } |
| 425 | |
| 426 | /* |
| 427 | * Get the MAP domain from an IPv6 lookup adjacency. |
| 428 | * If the IPv6 address or prefix is not shared, no lookup is required. |
| 429 | * The IPv4 address is used otherwise. |
| 430 | */ |
| 431 | static_always_inline map_domain_t * |
Neale Ranns | 9705c38 | 2017-02-20 20:29:41 -0800 | [diff] [blame] | 432 | ip6_map_get_domain (u32 mdi, |
| 433 | ip4_address_t *addr, |
| 434 | u32 *map_domain_index, |
| 435 | u8 *error) |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 436 | { |
| 437 | map_main_t *mm = &map_main; |
Ole Troan | 366ac6e | 2016-01-06 12:40:28 +0100 | [diff] [blame] | 438 | |
| 439 | /* |
| 440 | * Disable direct MAP domain lookup on decap, until the security check is updated to verify IPv4 SA. |
| 441 | * (That's done implicitly when MAP domain is looked up in the IPv4 FIB) |
| 442 | */ |
| 443 | #ifdef MAP_NONSHARED_DOMAIN_ENABLED |
Neale Ranns | 9705c38 | 2017-02-20 20:29:41 -0800 | [diff] [blame] | 444 | #error "How can you be sure this domain is not shared?" |
| 445 | *map_domain_index = mdi; |
| 446 | return pool_elt_at_index(mm->domains, mdi); |
Ole Troan | 366ac6e | 2016-01-06 12:40:28 +0100 | [diff] [blame] | 447 | #endif |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 448 | |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 449 | u32 lbi = ip4_fib_forwarding_lookup(0, addr); |
| 450 | const dpo_id_t *dpo = load_balance_get_bucket(lbi, 0); |
| 451 | if (PREDICT_TRUE(dpo->dpoi_type == map_dpo_type || |
| 452 | dpo->dpoi_type == map_t_dpo_type)) |
| 453 | { |
Neale Ranns | 9705c38 | 2017-02-20 20:29:41 -0800 | [diff] [blame] | 454 | *map_domain_index = dpo->dpoi_index; |
Neale Ranns | 0bfe5d8 | 2016-08-25 15:29:12 +0100 | [diff] [blame] | 455 | return pool_elt_at_index(mm->domains, *map_domain_index); |
| 456 | } |
Ed Warnicke | cb9cada | 2015-12-08 15:45:58 -0700 | [diff] [blame] | 457 | *error = MAP_ERROR_NO_DOMAIN; |
| 458 | return NULL; |
| 459 | } |
| 460 | |
| 461 | map_ip4_reass_t * |
| 462 | map_ip4_reass_get(u32 src, u32 dst, u16 fragment_id, |
| 463 | u8 protocol, u32 **pi_to_drop); |
| 464 | void |
| 465 | map_ip4_reass_free(map_ip4_reass_t *r, u32 **pi_to_drop); |
| 466 | |
| 467 | #define map_ip4_reass_lock() while (__sync_lock_test_and_set(map_main.ip4_reass_lock, 1)) {} |
| 468 | #define map_ip4_reass_unlock() do {CLIB_MEMORY_BARRIER(); *map_main.ip4_reass_lock = 0;} while(0) |
| 469 | |
| 470 | static_always_inline void |
| 471 | map_ip4_reass_get_fragments(map_ip4_reass_t *r, u32 **pi) |
| 472 | { |
| 473 | int i; |
| 474 | for (i=0; i<MAP_IP4_REASS_MAX_FRAGMENTS_PER_REASSEMBLY; i++) |
| 475 | if(r->fragments[i] != ~0) { |
| 476 | vec_add1(*pi, r->fragments[i]); |
| 477 | r->fragments[i] = ~0; |
| 478 | map_main.ip4_reass_buffered_counter--; |
| 479 | } |
| 480 | } |
| 481 | |
| 482 | int map_ip4_reass_add_fragment(map_ip4_reass_t *r, u32 pi); |
| 483 | |
| 484 | map_ip6_reass_t * |
| 485 | map_ip6_reass_get(ip6_address_t *src, ip6_address_t *dst, u32 fragment_id, |
| 486 | u8 protocol, u32 **pi_to_drop); |
| 487 | void |
| 488 | map_ip6_reass_free(map_ip6_reass_t *r, u32 **pi_to_drop); |
| 489 | |
| 490 | #define map_ip6_reass_lock() while (__sync_lock_test_and_set(map_main.ip6_reass_lock, 1)) {} |
| 491 | #define map_ip6_reass_unlock() do {CLIB_MEMORY_BARRIER(); *map_main.ip6_reass_lock = 0;} while(0) |
| 492 | |
| 493 | int |
| 494 | map_ip6_reass_add_fragment(map_ip6_reass_t *r, u32 pi, |
| 495 | u16 data_offset, u16 next_data_offset, |
| 496 | u8 *data_start, u16 data_len); |
| 497 | |
| 498 | void map_ip4_drop_pi(u32 pi); |
| 499 | |
| 500 | int map_ip4_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets); |
| 501 | #define MAP_IP4_REASS_CONF_HT_RATIO_MAX 100 |
| 502 | int map_ip4_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets); |
| 503 | #define MAP_IP4_REASS_CONF_POOL_SIZE_MAX (0xfeff) |
| 504 | int map_ip4_reass_conf_lifetime(u16 lifetime_ms); |
| 505 | #define MAP_IP4_REASS_CONF_LIFETIME_MAX 0xffff |
| 506 | int map_ip4_reass_conf_buffers(u32 buffers); |
| 507 | #define MAP_IP4_REASS_CONF_BUFFERS_MAX (0xffffffff) |
| 508 | |
| 509 | void map_ip6_drop_pi(u32 pi); |
| 510 | |
| 511 | |
| 512 | int map_ip6_reass_conf_ht_ratio(f32 ht_ratio, u32 *trashed_reass, u32 *dropped_packets); |
| 513 | #define MAP_IP6_REASS_CONF_HT_RATIO_MAX 100 |
| 514 | int map_ip6_reass_conf_pool_size(u16 pool_size, u32 *trashed_reass, u32 *dropped_packets); |
| 515 | #define MAP_IP6_REASS_CONF_POOL_SIZE_MAX (0xfeff) |
| 516 | int map_ip6_reass_conf_lifetime(u16 lifetime_ms); |
| 517 | #define MAP_IP6_REASS_CONF_LIFETIME_MAX 0xffff |
| 518 | int map_ip6_reass_conf_buffers(u32 buffers); |
| 519 | #define MAP_IP6_REASS_CONF_BUFFERS_MAX (0xffffffff) |
| 520 | |
| 521 | static_always_inline |
| 522 | int ip6_parse(const ip6_header_t *ip6, u32 buff_len, |
| 523 | u8 *l4_protocol, u16 *l4_offset, u16 *frag_hdr_offset) |
| 524 | { |
| 525 | if (ip6->protocol == IP_PROTOCOL_IPV6_FRAGMENTATION) { |
| 526 | *l4_protocol = ((ip6_frag_hdr_t *)(ip6 + 1))->next_hdr; |
| 527 | *frag_hdr_offset = sizeof(*ip6); |
| 528 | *l4_offset = sizeof(*ip6) + sizeof(ip6_frag_hdr_t); |
| 529 | } else { |
| 530 | *l4_protocol = ip6->protocol; |
| 531 | *frag_hdr_offset = 0; |
| 532 | *l4_offset = sizeof(*ip6); |
| 533 | } |
| 534 | |
| 535 | return (buff_len < (*l4_offset + 4)) || |
| 536 | (clib_net_to_host_u16(ip6->payload_length) < (*l4_offset + 4 - sizeof(*ip6))); |
| 537 | } |
| 538 | |
| 539 | |
| 540 | #define u8_ptr_add(ptr, index) (((u8 *)ptr) + index) |
| 541 | #define u16_net_add(u, val) clib_host_to_net_u16(clib_net_to_host_u16(u) + (val)) |
| 542 | |
| 543 | #define frag_id_6to4(id) ((id) ^ ((id) >> 16)) |
| 544 | |
| 545 | static_always_inline void |
| 546 | ip4_map_t_embedded_address (map_domain_t *d, |
| 547 | ip6_address_t *ip6, const ip4_address_t *ip4) |
| 548 | { |
| 549 | ASSERT(d->ip6_src_len == 96); //No support for other lengths for now |
| 550 | ip6->as_u64[0] = d->ip6_src.as_u64[0]; |
| 551 | ip6->as_u32[2] = d->ip6_src.as_u32[2]; |
| 552 | ip6->as_u32[3] = ip4->as_u32; |
| 553 | } |
| 554 | |
| 555 | static_always_inline u32 |
| 556 | ip6_map_t_embedded_address (map_domain_t *d, ip6_address_t *addr) |
| 557 | { |
| 558 | ASSERT(d->ip6_src_len == 96); //No support for other lengths for now |
| 559 | return addr->as_u32[3]; |
| 560 | } |
| 561 | |
| 562 | static inline void |
| 563 | map_domain_counter_lock (map_main_t *mm) |
| 564 | { |
| 565 | if (mm->counter_lock) |
| 566 | while (__sync_lock_test_and_set(mm->counter_lock, 1)) |
| 567 | /* zzzz */ ; |
| 568 | } |
| 569 | static inline void |
| 570 | map_domain_counter_unlock (map_main_t *mm) |
| 571 | { |
| 572 | if (mm->counter_lock) |
| 573 | *mm->counter_lock = 0; |
| 574 | } |
| 575 | |
| 576 | |
| 577 | static_always_inline void |
| 578 | map_send_all_to_node(vlib_main_t *vm, u32 *pi_vector, |
| 579 | vlib_node_runtime_t *node, vlib_error_t *error, |
| 580 | u32 next) |
| 581 | { |
| 582 | u32 n_left_from, *from, next_index, *to_next, n_left_to_next; |
| 583 | //Deal with fragments that are ready |
| 584 | from = pi_vector; |
| 585 | n_left_from = vec_len(pi_vector); |
| 586 | next_index = node->cached_next_index; |
| 587 | while (n_left_from > 0) { |
| 588 | vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next); |
| 589 | while (n_left_from > 0 && n_left_to_next > 0) { |
| 590 | u32 pi0 = to_next[0] = from[0]; |
| 591 | from += 1; |
| 592 | n_left_from -= 1; |
| 593 | to_next += 1; |
| 594 | n_left_to_next -= 1; |
| 595 | vlib_buffer_t *p0 = vlib_get_buffer(vm, pi0); |
| 596 | p0->error = *error; |
| 597 | vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, pi0, next); |
| 598 | } |
| 599 | vlib_put_next_frame(vm, node, next_index, n_left_to_next); |
| 600 | } |
| 601 | } |
Keith Burns (alagalah) | 06e3d07 | 2016-08-07 08:43:18 -0700 | [diff] [blame] | 602 | |
| 603 | /* |
| 604 | * fd.io coding-style-patch-verification: ON |
| 605 | * |
| 606 | * Local Variables: |
| 607 | * eval: (c-set-style "gnu") |
| 608 | * End: |
| 609 | */ |