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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 * Defines used for testing various optimisation schemes
20 #include <vnet/ip/ip_frag.h>
21 #include <vnet/ip/ip4_to_ip6.h>
25 IP4_MAP_NEXT_IP6_LOOKUP,
26 #ifdef MAP_SKIP_IP6_LOOKUP
27 IP4_MAP_NEXT_IP6_REWRITE,
29 IP4_MAP_NEXT_ICMP_ERROR,
34 static_always_inline u16
35 ip4_map_port_and_security_check (map_domain_t * d, vlib_buffer_t * b0,
39 if (d->psid_length > 0)
41 ip4_header_t *ip = vlib_buffer_get_current (b0);
44 ((ip->ip_version_and_header_length != 0x45)
45 || clib_host_to_net_u16 (ip->length) < 28))
50 port = vnet_buffer (b0)->ip.reass.l4_dst_port;
52 /* Verify that port is not among the well-known ports */
53 if ((d->psid_offset > 0)
54 && (clib_net_to_host_u16 (port) < (0x1 << (16 - d->psid_offset))))
56 *error = MAP_ERROR_ENCAP_SEC_CHECK;
69 static_always_inline u32
70 ip4_map_vtcfl (ip4_header_t * ip4, vlib_buffer_t * p)
72 map_main_t *mm = &map_main;
73 u8 tc = mm->tc_copy ? ip4->tos : mm->tc;
74 u32 vtcfl = 0x6 << 28;
76 vtcfl |= vnet_buffer (p)->ip.flow_hash & 0x000fffff;
78 return (clib_host_to_net_u32 (vtcfl));
81 static_always_inline bool
82 ip4_map_ip6_lookup_bypass (vlib_buffer_t * p0, ip4_header_t * ip)
84 #ifdef MAP_SKIP_IP6_LOOKUP
85 if (FIB_NODE_INDEX_INVALID != pre_resolved[FIB_PROTOCOL_IP6].fei)
87 vnet_buffer (p0)->ip.adj_index[VLIB_TX] =
88 pre_resolved[FIB_PROTOCOL_IP6].dpo.dpoi_index;
99 ip4_map_decrement_ttl (ip4_header_t * ip, u8 * error)
103 /* Input node should have reject packets with ttl 0. */
104 ASSERT (ip->ttl > 0);
106 u32 checksum = ip->checksum + clib_host_to_net_u16 (0x0100);
107 checksum += checksum >= 0xffff;
108 ip->checksum = checksum;
111 *error = ttl <= 0 ? IP4_ERROR_TIME_EXPIRED : *error;
113 /* Verify checksum. */
114 ASSERT (ip->checksum == ip4_header_checksum (ip));
118 ip4_map_fragment (vlib_main_t * vm, u32 bi, u16 mtu, bool df, u32 ** buffers,
121 map_main_t *mm = &map_main;
122 vlib_buffer_t *b = vlib_get_buffer (vm, bi);
126 /* IPv4 fragmented packets inside of IPv6 */
127 ip4_frag_do_fragment (vm, bi, mtu, sizeof (ip6_header_t), buffers);
131 vec_foreach (i, *buffers)
133 vlib_buffer_t *p = vlib_get_buffer (vm, *i);
134 ip6_header_t *ip6 = vlib_buffer_get_current (p);
135 ip6->payload_length =
136 clib_host_to_net_u16 (p->current_length - sizeof (ip6_header_t));
141 if (df && !mm->frag_ignore_df)
143 icmp4_error_set_vnet_buffer (b, ICMP4_destination_unreachable,
144 ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
146 vlib_buffer_advance (b, sizeof (ip6_header_t));
147 *error = MAP_ERROR_DF_SET;
148 return (IP4_MAP_NEXT_ICMP_ERROR);
151 /* Create IPv6 fragments here */
152 ip6_frag_do_fragment (vm, bi, mtu, 0, buffers);
154 return (IP4_MAP_NEXT_IP6_LOOKUP);
161 ip4_map (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
163 u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
164 vlib_node_runtime_t *error_node =
165 vlib_node_get_runtime (vm, ip4_map_node.index);
166 from = vlib_frame_vector_args (frame);
167 n_left_from = frame->n_vectors;
168 next_index = node->cached_next_index;
169 map_main_t *mm = &map_main;
170 vlib_combined_counter_main_t *cm = mm->domain_counters;
171 u32 thread_index = vm->thread_index;
173 while (n_left_from > 0)
175 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
176 while (n_left_from > 0 && n_left_to_next > 0)
181 u8 error0 = MAP_ERROR_NONE;
185 u32 next0 = IP4_MAP_NEXT_IP6_LOOKUP;
186 u32 map_domain_index0 = ~0;
188 bool free_original_buffer0 = false;
189 u32 *frag_from0, frag_left0;
191 pi0 = to_next[0] = from[0];
195 p0 = vlib_get_buffer (vm, pi0);
196 ip40 = vlib_buffer_get_current (p0);
199 ip4_map_get_domain (&ip40->dst_address, &map_domain_index0,
202 { /* Guess it wasn't for us */
203 vnet_feature_next (&next0, p0);
208 * Shared IPv4 address
210 port0 = ip4_map_port_and_security_check (d0, p0, &error0);
213 * Clamp TCP MSS value.
215 if (ip40->protocol == IP_PROTOCOL_TCP)
217 tcp_header_t *tcp = ip4_next_header (ip40);
218 if (mm->tcp_mss > 0 && tcp_syn (tcp))
220 ip_csum_t csum = tcp->checksum;
221 map_mss_clamping (tcp, &csum, mm->tcp_mss);
222 tcp->checksum = ip_csum_fold (csum);
226 /* Decrement IPv4 TTL */
227 ip4_map_decrement_ttl (ip40, &error0);
229 ip40->flags_and_fragment_offset &
230 clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT);
233 u32 da40 = clib_net_to_host_u32 (ip40->dst_address.as_u32);
234 u16 dp40 = clib_net_to_host_u16 (port0);
235 u64 dal60 = map_get_pfx (d0, da40, dp40);
236 u64 dar60 = map_get_sfx (d0, da40, dp40);
237 if (dal60 == 0 && dar60 == 0 && error0 == MAP_ERROR_NONE)
238 error0 = MAP_ERROR_NO_BINDING;
240 /* construct ipv6 header */
241 vlib_buffer_advance (p0, -(sizeof (ip6_header_t)));
242 ip6h0 = vlib_buffer_get_current (p0);
243 vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
245 ip6h0->ip_version_traffic_class_and_flow_label =
246 ip4_map_vtcfl (ip40, p0);
247 ip6h0->payload_length = ip40->length;
248 ip6h0->protocol = IP_PROTOCOL_IP_IN_IP;
249 ip6h0->hop_limit = 0x40;
250 ip6h0->src_address = d0->ip6_src;
251 ip6h0->dst_address.as_u64[0] = clib_host_to_net_u64 (dal60);
252 ip6h0->dst_address.as_u64[1] = clib_host_to_net_u64 (dar60);
255 * Determine next node. Can be one of:
256 * ip6-lookup, ip6-rewrite, error-drop
258 if (PREDICT_TRUE (error0 == MAP_ERROR_NONE))
262 && (clib_net_to_host_u16 (ip6h0->payload_length) +
263 sizeof (*ip6h0) > d0->mtu)))
266 ip4_map_fragment (vm, pi0, d0->mtu, df0, &buffer0,
269 if (error0 == MAP_ERROR_NONE)
271 free_original_buffer0 = true;
277 ip4_map_ip6_lookup_bypass (p0,
279 IP4_MAP_NEXT_IP6_REWRITE : next0;
280 vlib_increment_combined_counter (cm + MAP_DOMAIN_COUNTER_TX,
282 map_domain_index0, 1,
284 (ip6h0->payload_length) +
290 next0 = IP4_MAP_NEXT_DROP;
293 if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
295 map_add_trace (vm, node, p0, map_domain_index0, port0);
298 p0->error = error_node->errors[error0];
300 /* Send fragments that were added in the frame */
301 if (free_original_buffer0)
303 vlib_buffer_free_one (vm, pi0); /* Free original packet */
307 vec_add1 (buffer0, pi0);
310 frag_from0 = buffer0;
311 frag_left0 = vec_len (buffer0);
313 while (frag_left0 > 0)
315 while (frag_left0 > 0 && n_left_to_next > 0)
318 i0 = to_next[0] = frag_from0[0];
324 vlib_get_buffer (vm, i0)->error =
325 error_node->errors[error0];
326 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
327 to_next, n_left_to_next,
330 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
331 vlib_get_next_frame (vm, node, next_index, to_next,
334 vec_reset_length (buffer0);
336 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
339 return frame->n_vectors;
342 static char *map_error_strings[] = {
343 #define _(sym,string) string,
350 VNET_FEATURE_INIT (ip4_map_feature, static) =
352 .arc_name = "ip4-unicast",
353 .node_name = "ip4-map",
354 .runs_before = VNET_FEATURES ("ip4-flow-classify"),
355 .runs_after = VNET_FEATURES("ip4-sv-reassembly-feature"),
358 VLIB_REGISTER_NODE(ip4_map_node) = {
361 .vector_size = sizeof(u32),
362 .format_trace = format_map_trace,
363 .type = VLIB_NODE_TYPE_INTERNAL,
365 .n_errors = MAP_N_ERROR,
366 .error_strings = map_error_strings,
368 .n_next_nodes = IP4_MAP_N_NEXT,
370 [IP4_MAP_NEXT_IP6_LOOKUP] = "ip6-lookup",
371 #ifdef MAP_SKIP_IP6_LOOKUP
372 [IP4_MAP_NEXT_IP6_REWRITE] = "ip6-load-balance",
374 [IP4_MAP_NEXT_ICMP_ERROR] = "ip4-icmp-error",
375 [IP4_MAP_NEXT_DROP] = "error-drop",
381 * fd.io coding-style-patch-verification: ON
384 * eval: (c-set-style "gnu")