2 * Copyright (c) 2020 Arrcus Inc 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.
15 #include <vlib/vlib.h>
16 #include <vnet/vnet.h>
17 #include <vppinfra/error.h>
18 #include <vppinfra/hash.h>
19 #include <srv6-mobile/mobile.h>
21 extern ip6_address_t sr_pr_encaps_src;
25 ip6_address_t src, dst;
26 ip6_address_t sr_prefix;
29 } srv6_end_rewrite_trace_t;
31 static u16 srh_tagfield[256] = {
34 /* 1 : Echo Request */
39 0x0, 0x0, 0x0, 0x0, 0x0,
41 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
43 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
46 /* 26 : Error Indication */
49 0x0, 0x0, 0x0, 0x0, 0x0,
51 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
52 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
53 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
54 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
55 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
56 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
57 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
58 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
59 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
60 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
61 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
62 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
63 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
64 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
65 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
66 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
67 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
68 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
69 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
70 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
71 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
72 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
73 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
74 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
75 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
76 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
77 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
79 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
87 format_srv6_end_rewrite_trace (u8 * s, va_list * args)
89 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
90 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
91 srv6_end_rewrite_trace_t *t = va_arg (*args, srv6_end_rewrite_trace_t *);
93 return format (s, "SRv6-END-rewrite: src %U dst %U\n\tTEID: 0x%x",
94 format_ip4_address, &t->src, format_ip4_address, &t->dst,
95 clib_net_to_host_u32 (t->teid));
99 format_srv6_end_rewrite_trace6 (u8 * s, va_list * args)
101 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
102 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
103 srv6_end_rewrite_trace_t *t = va_arg (*args, srv6_end_rewrite_trace_t *);
106 "SRv6-END-rewrite: src %U dst %U\n\tTEID: 0x%x\n\tsr_prefix: %U/%d",
107 format_ip6_address, &t->src, format_ip6_address, &t->dst,
108 clib_net_to_host_u32 (t->teid), format_ip6_address,
109 &t->sr_prefix, t->sr_prefixlen);
112 #define foreach_srv6_end_v4_error \
113 _(M_GTP4_E_PACKETS, "srv6 End.M.GTP4.E packets") \
114 _(M_GTP4_E_BAD_PACKETS, "srv6 End.M.GTP4.E bad packets")
116 #define foreach_srv6_t_v4_d_error \
117 _(M_GTP4_D_PACKETS, "srv6 T.M.GTP4.D packets") \
118 _(M_GTP4_D_BAD_PACKETS, "srv6 T.M.GTP4.D bad packets")
120 #define foreach_srv6_end_v6_e_error \
121 _(M_GTP6_E_PACKETS, "srv6 End.M.GTP6.E packets") \
122 _(M_GTP6_E_BAD_PACKETS, "srv6 End.M.GTP6.E bad packets")
124 #define foreach_srv6_end_v6_d_error \
125 _(M_GTP6_D_PACKETS, "srv6 End.M.GTP6.D packets") \
126 _(M_GTP6_D_BAD_PACKETS, "srv6 End.M.GTP6.D bad packets")
128 #define foreach_srv6_end_v6_d_di_error \
129 _(M_GTP6_D_DI_PACKETS, "srv6 End.M.GTP6.D.DI packets") \
130 _(M_GTP6_D_DI_BAD_PACKETS, "srv6 End.M.GTP6.D.DI bad packets")
132 #define foreach_srv6_end_v6_dt_error \
133 _(M_GTP6_DT_PACKETS, "srv6 End.M.GTP6.DT packets") \
134 _(M_GTP6_DT_BAD_PACKETS, "srv6 End.M.GTP6.DT bad packets")
136 #define foreach_srv6_t_v4_dt_error \
137 _(M_GTP4_DT_PACKETS, "srv6 T.M.GTP4.DT packets") \
138 _(M_GTP4_DT_BAD_PACKETS, "srv6 T.M.GTP4.DT bad packets")
142 #define _(sym,str) SRV6_END_ERROR_##sym,
143 foreach_srv6_end_v4_error
146 } srv6_end_error_v4_t;
150 #define _(sym,str) SRV6_T_ERROR_##sym,
151 foreach_srv6_t_v4_d_error
154 } srv6_t_error_v4_d_t;
158 #define _(sym,str) SRV6_END_ERROR_##sym,
159 foreach_srv6_end_v6_e_error
161 SRV6_END_N_V6_E_ERROR,
162 } srv6_end_error_v6_e_t;
166 #define _(sym,str) SRV6_END_ERROR_##sym,
167 foreach_srv6_end_v6_d_error
169 SRV6_END_N_V6_D_ERROR,
170 } srv6_end_error_v6_d_t;
174 #define _(sym,str) SRV6_END_ERROR_##sym,
175 foreach_srv6_end_v6_d_di_error
177 SRV6_END_N_V6_D_DI_ERROR,
178 } srv6_end_error_v6_d_di_t;
182 #define _(sym,str) SRV6_END_ERROR_##sym,
183 foreach_srv6_end_v6_dt_error
185 SRV6_END_N_V6_DT_ERROR,
186 } srv6_end_error_v6_dt_t;
190 #define _(sym,str) SRV6_T_ERROR_##sym,
191 foreach_srv6_t_v4_dt_error
193 SRV6_T_N_V4_DT_ERROR,
194 } srv6_t_error_v4_dt_t;
196 static char *srv6_end_error_v4_strings[] = {
197 #define _(sym,string) string,
198 foreach_srv6_end_v4_error
202 static char *srv6_t_error_v4_d_strings[] = {
203 #define _(sym,string) string,
204 foreach_srv6_t_v4_d_error
208 static char *srv6_end_error_v6_e_strings[] = {
209 #define _(sym,string) string,
210 foreach_srv6_end_v6_e_error
214 static char *srv6_end_error_v6_d_strings[] = {
215 #define _(sym,string) string,
216 foreach_srv6_end_v6_d_error
220 static char *srv6_end_error_v6_d_di_strings[] = {
221 #define _(sym,string) string,
222 foreach_srv6_end_v6_d_di_error
226 static char *srv6_end_error_v6_dt_strings[] = {
227 #define _(sym,string) string,
228 foreach_srv6_end_v6_dt_error
232 static char *srv6_t_error_v4_dt_strings[] = {
233 #define _(sym,string) string,
234 foreach_srv6_t_v4_dt_error
240 SRV6_END_M_GTP4_E_NEXT_DROP,
241 SRV6_END_M_GTP4_E_NEXT_LOOKUP,
242 SRV6_END_M_GTP4_E_N_NEXT,
243 } srv6_end_m_gtp4_e_next_t;
247 SRV6_T_M_GTP4_D_NEXT_DROP,
248 SRV6_T_M_GTP4_D_NEXT_LOOKUP,
249 SRV6_T_M_GTP4_D_N_NEXT,
250 } srv6_T_m_gtp4_d_next_t;
254 SRV6_END_M_GTP6_E_NEXT_DROP,
255 SRV6_END_M_GTP6_E_NEXT_LOOKUP,
256 SRV6_END_M_GTP6_E_N_NEXT,
257 } srv6_end_m_gtp6_e_next_t;
261 SRV6_END_M_GTP6_D_NEXT_DROP,
262 SRV6_END_M_GTP6_D_NEXT_LOOKUP,
263 SRV6_END_M_GTP6_D_N_NEXT,
264 } srv6_end_m_gtp6_d_next_t;
268 SRV6_END_M_GTP6_D_DI_NEXT_DROP,
269 SRV6_END_M_GTP6_D_DI_NEXT_LOOKUP,
270 SRV6_END_M_GTP6_D_DI_N_NEXT,
271 } srv6_end_m_gtp6_d_di_next_t;
275 SRV6_END_M_GTP6_DT_NEXT_DROP,
276 SRV6_END_M_GTP6_DT_NEXT_LOOKUP4,
277 SRV6_END_M_GTP6_DT_NEXT_LOOKUP6,
278 SRV6_END_M_GTP6_DT_N_NEXT,
279 } srv6_end_m_gtp6_dt_next_t;
283 SRV6_T_M_GTP4_DT_NEXT_DROP,
284 SRV6_T_M_GTP4_DT_NEXT_LOOKUP4,
285 SRV6_T_M_GTP4_DT_NEXT_LOOKUP6,
286 SRV6_T_M_GTP4_DT_N_NEXT,
287 } srv6_t_m_gtp4_dt_next_t;
290 hash_uword_to_u16 (uword * key)
295 return val[0] ^ val[1] ^ val[2] ^ val[3];
297 return val[0] ^ val[1];
302 gtpu_type_get (u16 tag)
306 val = clib_net_to_host_u16 (tag);
307 if (val & SRH_TAG_ECHO_REPLY)
308 return GTPU_TYPE_ECHO_REPLY;
309 else if (val & SRH_TAG_ECHO_REQUEST)
310 return GTPU_TYPE_ECHO_REQUEST;
311 else if (val & SRH_TAG_ERROR_INDICATION)
312 return GTPU_TYPE_ERROR_INDICATION;
313 else if (val & SRH_TAG_END_MARKER)
314 return GTPU_TYPE_END_MARKER;
316 return GTPU_TYPE_GTPU;
319 // Function for SRv6 GTP4.E function.
320 VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm,
321 vlib_node_runtime_t * node,
322 vlib_frame_t * frame)
324 srv6_end_main_v4_t *sm = &srv6_end_main_v4;
325 ip6_sr_main_t *sm2 = &sr_main;
326 u32 n_left_from, next_index, *from, *to_next;
327 u32 thread_index = vm->thread_index;
329 u32 good_n = 0, bad_n = 0;
331 from = vlib_frame_vector_args (frame);
332 n_left_from = frame->n_vectors;
333 next_index = node->cached_next_index;
335 while (n_left_from > 0)
339 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
341 while (n_left_from > 0 && n_left_to_next > 0)
345 ip6_sr_localsid_t *ls0;
346 srv6_end_gtp4_param_t *ls_param;
348 ip6srv_combo_header_t *ip6srv0;
349 ip6_address_t src0, dst0;
351 ip4_gtpu_header_t *hdr0 = NULL;
354 u32 next0 = SRV6_END_M_GTP4_E_NEXT_LOOKUP;
364 b0 = vlib_get_buffer (vm, bi0);
366 pool_elt_at_index (sm2->localsids,
367 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
369 ls_param = (srv6_end_gtp4_param_t *) ls0->plugin_mem;
371 ip6srv0 = vlib_buffer_get_current (b0);
372 src0 = ip6srv0->ip.src_address;
373 dst0 = ip6srv0->ip.dst_address;
375 len0 = vlib_buffer_length_in_chain (vm, b0);
377 if ((ip6srv0->ip.protocol == IPPROTO_IPV6_ROUTE
379 sizeof (ip6srv_combo_header_t) + ip6srv0->sr.length * 8)
380 || (len0 < sizeof (ip6_header_t)))
382 next0 = SRV6_END_M_GTP4_E_NEXT_DROP;
391 u8 *teid8p = (u8 *) & teid;
401 u8 ie_buf[GTPU_IE_MAX_SIZ];
405 if (ip6srv0->ip.protocol == IPPROTO_IPV6_ROUTE)
407 tag = ip6srv0->sr.tag;
410 offset = ls0->localsid_prefix_len / 8;
411 shift = ls0->localsid_prefix_len % 8;
413 gtpu_type = gtpu_type_get (tag);
415 if (PREDICT_TRUE (shift == 0))
417 clib_memcpy_fast (&dst4.as_u8[0], &dst0.as_u8[offset], 4);
419 qfi = dst0.as_u8[offset + 4];
421 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
422 || gtpu_type == GTPU_TYPE_ECHO_REPLY
423 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
425 clib_memcpy_fast (&seq, &dst0.as_u8[offset + 5], 2);
429 clib_memcpy_fast (teid8p, &dst0.as_u8[offset + 5], 4);
436 for (index = 0; index < 4; index++)
438 dst4.as_u8[index] = dst0.as_u8[offset + index] << shift;
440 dst0.as_u8[offset + index + 1] >> (8 - shift);
443 qfi |= dst0.as_u8[offset + 4] << shift;
444 qfi |= dst0.as_u8[offset + 5] >> (8 - shift);
446 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
447 || gtpu_type == GTPU_TYPE_ECHO_REPLY
448 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
451 for (index = 0; index < 2; index++)
453 sp[index] = dst0.as_u8[offset + 5 + index] << shift;
455 dst0.as_u8[offset + 6 + index] >> (8 - shift);
460 for (index = 0; index < 4; index++)
462 *teid8p = dst0.as_u8[offset + 5 + index] << shift;
464 dst0.as_u8[offset + 6 + index] >> (8 - shift);
473 sizeof (gtpu_exthdr_t) + sizeof (gtpu_pdu_session_t);
475 else if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
476 || gtpu_type == GTPU_TYPE_ECHO_REPLY
477 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
479 hdrlen = sizeof (gtpu_exthdr_t);
482 if (PREDICT_FALSE (gtpu_type == GTPU_TYPE_ECHO_REPLY))
484 hdrlen += sizeof (gtpu_recovery_ie);
487 if (PREDICT_FALSE (gtpu_type == GTPU_TYPE_ERROR_INDICATION))
492 ext_len = ip6srv0->sr.length * 8;
495 sizeof (ip6_address_t) * (ip6srv0->sr.last_entry + 1))
498 (ip6_sr_tlv_t *) ((u8 *) & ip6srv0->sr +
499 sizeof (ip6_sr_header_t) +
500 sizeof (ip6_address_t) *
501 (ip6srv0->sr.last_entry + 1));
503 if (tlv->type == SRH_TLV_USER_PLANE_CONTAINER)
505 user_plane_sub_tlv_t *sub_tlv;
507 sub_tlv = (user_plane_sub_tlv_t *) tlv->value;
509 ie_size = sub_tlv->length;
510 clib_memcpy_fast (ie_buf, sub_tlv->value, ie_size);
517 if (ip6srv0->ip.protocol == IPPROTO_IPV6_ROUTE)
519 vlib_buffer_advance (b0,
520 (word) sizeof (ip6srv_combo_header_t) +
521 ip6srv0->sr.length * 8);
525 vlib_buffer_advance (b0, (word) sizeof (ip6_header_t));
528 // get length of encapsulated IPv6 packet (the remaining part)
529 p = vlib_buffer_get_current (b0);
531 plen = len0 = vlib_buffer_length_in_chain (vm, b0);
535 hdrlen += sizeof (ip4_gtpu_header_t);
537 // IPv4 GTP-U header creation.
538 vlib_buffer_advance (b0, -(word) hdrlen);
540 hdr0 = vlib_buffer_get_current (b0);
542 clib_memcpy_fast (hdr0, &sm->cache_hdr,
543 sizeof (ip4_gtpu_header_t));
545 hdr0->ip4.dst_address.as_u32 = dst4.as_u32;
547 hdr0->gtpu.teid = teid;
548 hdr0->gtpu.length = clib_host_to_net_u16 (len0);
550 hdr0->gtpu.type = gtpu_type;
555 gtpu_pdu_session_t *sess;
557 hdr0->gtpu.ver_flags |= GTPU_EXTHDR_FLAG;
559 hdr0->gtpu.ext->seq = 0;
561 hdr0->gtpu.ext->npdu_num = 0;
562 hdr0->gtpu.ext->nextexthdr = GTPU_EXTHDR_PDU_SESSION;
564 type = qfi & SRV6_PDU_SESSION_U_BIT_MASK;
567 ((qfi & SRV6_PDU_SESSION_QFI_MASK) >> 2) |
568 ((qfi & SRV6_PDU_SESSION_R_BIT_MASK) << 5);
571 (gtpu_pdu_session_t *) (((char *) hdr0) +
572 sizeof (ip4_gtpu_header_t) +
573 sizeof (gtpu_exthdr_t));
578 sess->nextexthdr = 0;
581 if (gtpu_type == GTPU_TYPE_ECHO_REPLY
582 || gtpu_type == GTPU_TYPE_ECHO_REQUEST
583 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
585 hdr0->gtpu.ver_flags |= GTPU_SEQ_FLAG;
586 hdr0->gtpu.ext->seq = seq;
587 hdr0->gtpu.ext->npdu_num = 0;
588 hdr0->gtpu.ext->nextexthdr = 0;
590 if (gtpu_type == GTPU_TYPE_ECHO_REPLY)
592 gtpu_recovery_ie *recovery;
595 (gtpu_recovery_ie *) ((u8 *) hdr0 +
597 sizeof (gtpu_recovery_ie)));
598 recovery->type = GTPU_RECOVERY_IE_TYPE;
599 recovery->restart_counter = 0;
601 else if (gtpu_type == GTPU_TYPE_ERROR_INDICATION)
607 ie_ptr = (u8 *) ((u8 *) hdr0 + (hdrlen - ie_size));
608 clib_memcpy_fast (ie_ptr, ie_buf, ie_size);
613 offset = ls_param->v4src_position / 8;
614 shift = ls_param->v4src_position % 8;
616 if (PREDICT_TRUE (shift == 0))
618 for (index = 0; index < 4; index++)
620 hdr0->ip4.src_address.as_u8[index] =
621 src0.as_u8[offset + index];
626 for (index = 0; index < 4; index++)
628 hdr0->ip4.src_address.as_u8[index] =
629 src0.as_u8[offset + index] << shift;
630 hdr0->ip4.src_address.as_u8[index] |=
631 src0.as_u8[offset + index + 1] >> (8 - shift);
635 key = hash_memory (p, plen < 40 ? plen : 40, 0);
636 port = hash_uword_to_u16 (&key);
637 hdr0->udp.src_port = port;
639 hdr0->udp.length = clib_host_to_net_u16 (len0 +
640 sizeof (udp_header_t) +
644 hdr0->ip4.length = clib_host_to_net_u16 (len0 +
646 (ip4_gtpu_header_t));
648 hdr0->ip4.checksum = ip4_header_checksum (&hdr0->ip4);
652 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
653 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
655 srv6_end_rewrite_trace_t *tr =
656 vlib_add_trace (vm, node, b0, sizeof (*tr));
657 clib_memcpy (tr->src.as_u8, hdr0->ip4.src_address.as_u8,
658 sizeof (tr->src.as_u8));
659 clib_memcpy (tr->dst.as_u8, hdr0->ip4.dst_address.as_u8,
660 sizeof (tr->dst.as_u8));
661 tr->teid = hdr0->gtpu.teid;
665 vlib_increment_combined_counter
667 SRV6_END_M_GTP4_E_NEXT_DROP) ? &(sm2->sr_ls_invalid_counters) :
668 &(sm2->sr_ls_valid_counters)), thread_index,
669 ls0 - sm2->localsids, 1, vlib_buffer_length_in_chain (vm, b0));
671 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
672 n_left_to_next, bi0, next0);
675 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
678 vlib_node_increment_counter (vm, sm->end_m_gtp4_e_node_index,
679 SRV6_END_ERROR_M_GTP4_E_BAD_PACKETS, bad_n);
681 vlib_node_increment_counter (vm, sm->end_m_gtp4_e_node_index,
682 SRV6_END_ERROR_M_GTP4_E_PACKETS, good_n);
684 return frame->n_vectors;
687 // Function for SRv6 GTP4.D function.
688 VLIB_NODE_FN (srv6_t_m_gtp4_d) (vlib_main_t * vm,
689 vlib_node_runtime_t * node,
690 vlib_frame_t * frame)
692 srv6_t_main_v4_decap_t *sm = &srv6_t_main_v4_decap;
693 ip6_sr_main_t *sm2 = &sr_main;
694 u32 n_left_from, next_index, *from, *to_next;
696 u32 good_n = 0, bad_n = 0;
698 from = vlib_frame_vector_args (frame);
699 n_left_from = frame->n_vectors;
700 next_index = node->cached_next_index;
702 while (n_left_from > 0)
706 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
708 while (n_left_from > 0 && n_left_to_next > 0)
713 srv6_end_gtp4_param_t *ls_param;
718 u32 next0 = SRV6_T_M_GTP4_D_NEXT_LOOKUP;
728 b0 = vlib_get_buffer (vm, bi0);
731 pool_elt_at_index (sm2->sid_lists,
732 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
734 ls_param = (srv6_end_gtp4_param_t *) sl0->plugin_mem;
736 len0 = vlib_buffer_length_in_chain (vm, b0);
738 ip4 = vlib_buffer_get_current (b0);
740 if (ip4->protocol != IP_PROTOCOL_UDP
741 || len0 < sizeof (ip4_gtpu_header_t))
743 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
750 ip6_sr_policy_t *sr_policy = NULL;
751 ip6_sr_sl_t *sl = NULL;
755 ip4_gtpu_header_t *hdr;
756 ip4_address_t src, dst;
758 ip6_header_t *encap = NULL;
768 u32 offset, shift, index;
769 ip6srv_combo_header_t *ip6srv;
770 gtpu_pdu_session_t *sess = NULL;
773 u8 ie_buf[GTPU_IE_MAX_SIZ];
776 hdr = (ip4_gtpu_header_t *) ip4;
778 hdr_len = sizeof (ip4_gtpu_header_t);
780 teid = hdr->gtpu.teid;
781 teidp = (u8 *) & teid;
785 gtpu_type = hdr->gtpu.type;
787 if (hdr->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
790 hdr_len += sizeof (gtpu_exthdr_t);
792 seq = hdr->gtpu.ext->seq;
794 if (hdr->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
796 // PDU Session Container.
798 (gtpu_pdu_session_t *) (((char *) hdr) + hdr_len);
799 qfi = sess->u.val & ~GTPU_PDU_SESSION_P_BIT_MASK;
802 hdr_len += sizeof (gtpu_pdu_session_t);
804 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
806 hdr_len += sizeof (gtpu_paging_policy_t);
811 src = hdr->ip4.src_address;
814 dst = hdr->ip4.dst_address;
817 seg = ls_param->sr_prefix;
819 offset = ls_param->sr_prefixlen / 8;
820 shift = ls_param->sr_prefixlen % 8;
822 if (PREDICT_TRUE (shift == 0))
824 clib_memcpy_fast (&seg.as_u8[offset], dstp, 4);
829 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
830 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
834 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
837 seg.as_u8[offset + 4] = qfi;
840 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
841 || gtpu_type == GTPU_TYPE_ECHO_REPLY
842 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
844 clib_memcpy_fast (&seg.as_u8[offset + 5], seqp, 2);
848 clib_memcpy_fast (&seg.as_u8[offset + 5], teidp, 4);
853 for (index = 0; index < 4; index++)
855 seg.as_u8[offset + index] |= dstp[index] >> shift;
856 seg.as_u8[offset + index + 1] |=
857 dstp[index] << (8 - shift);
863 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
864 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
868 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
871 seg.as_u8[offset + 4] |= qfi >> shift;
872 seg.as_u8[offset + 5] |= qfi << (8 - shift);
875 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
876 || gtpu_type == GTPU_TYPE_ECHO_REPLY
877 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
879 for (index = 0; index < 2; index++)
881 seg.as_u8[offset + 5 + index] |=
882 seqp[index] >> shift;
883 seg.as_u8[offset + 6 + index] |=
884 seqp[index] << (8 - shift);
889 for (index = 0; index < 4; index++)
891 seg.as_u8[offset + index + 5] |=
892 teidp[index] >> shift;
893 seg.as_u8[offset + index + 6] |=
894 teidp[index] << (8 - shift);
899 if (PREDICT_FALSE (gtpu_type == GTPU_TYPE_ERROR_INDICATION))
903 payload_len = clib_net_to_host_u16 (hdr->gtpu.length);
904 if (payload_len != 0)
907 payload_len - (hdr_len - sizeof (ip4_gtpu_header_t));
912 ies = (u8 *) ((u8 *) hdr + hdr_len);
913 clib_memcpy_fast (ie_buf, ies, ie_size);
919 src6 = ls_param->v6src_prefix;
921 offset = ls_param->v6src_prefixlen / 8;
922 shift = ls_param->v6src_prefixlen % 8;
924 if (PREDICT_TRUE (shift == 0))
926 clib_memcpy_fast (&src6.as_u8[offset], srcp, 4);
930 for (index = 0; index < 4; index++)
932 src6.as_u8[offset + index] |= srcp[offset] >> shift;
933 src6.as_u8[offset + index + 1] |=
934 srcp[offset] << (8 - shift);
938 vlib_buffer_advance (b0, (word) hdr_len);
941 if (PREDICT_TRUE (gtpu_type == GTPU_TYPE_GTPU))
943 encap = vlib_buffer_get_current (b0);
946 len0 = vlib_buffer_length_in_chain (vm, b0);
949 mhash_get (&sm2->sr_policies_index_hash,
950 &ls_param->sr_prefix);
953 sr_policy = pool_elt_at_index (sm2->sr_policies, p[0]);
958 vec_foreach (sl_index, sr_policy->segments_lists)
960 sl = pool_elt_at_index (sm2->sid_lists, *sl_index);
968 hdr_len = sizeof (ip6srv_combo_header_t);
969 hdr_len += vec_len (sl->segments) * sizeof (ip6_address_t);
970 hdr_len += sizeof (ip6_address_t);
974 hdr_len = sizeof (ip6_header_t);
976 if (PREDICT_FALSE (gtpu_type != GTPU_TYPE_GTPU))
978 hdr_len += sizeof (ip6_sr_header_t);
979 hdr_len += sizeof (ip6_address_t);
986 sizeof (ip6_sr_tlv_t) + sizeof (user_plane_sub_tlv_t) +
989 tlv_siz = (tlv_siz & ~0x07) + (tlv_siz & 0x07 ? 0x08 : 0x0);
993 vlib_buffer_advance (b0, -(word) hdr_len);
994 ip6srv = vlib_buffer_get_current (b0);
998 clib_memcpy_fast (ip6srv, sl->rewrite,
999 vec_len (sl->rewrite));
1001 if (vec_len (sl->segments) > 1)
1004 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1006 ip6srv->sr.segments_left += 1;
1007 ip6srv->sr.last_entry += 1;
1009 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
1010 ip6srv->sr.segments[0] = seg;
1012 clib_memcpy_fast (&ip6srv->sr.segments[1],
1013 (u8 *) (sl->rewrite +
1014 sizeof (ip6_header_t) +
1015 sizeof (ip6_sr_header_t)),
1016 vec_len (sl->segments) *
1017 sizeof (ip6_address_t));
1021 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
1023 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
1025 ip6srv->sr.segments_left = 1;
1026 ip6srv->sr.last_entry = 0;
1029 ((sizeof (ip6_sr_header_t) +
1030 sizeof (ip6_address_t)) / 8) - 1;
1031 ip6srv->sr.flags = 0;
1034 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1036 ip6srv->sr.segments[0] = seg;
1037 if (vec_len (sl->segments))
1039 ip6srv->sr.segments[1] = sl->segments[0];
1040 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
1041 ip6srv->sr.last_entry++;
1045 if (PREDICT_TRUE (encap != NULL))
1047 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
1049 if ((clib_net_to_host_u32
1050 (encap->ip_version_traffic_class_and_flow_label)
1052 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
1054 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
1056 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
1058 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
1059 if ((clib_net_to_host_u32
1060 (encap->ip_version_traffic_class_and_flow_label)
1063 // Bad encap packet.
1064 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
1069 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
1071 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
1072 if ((clib_net_to_host_u32
1073 (encap->ip_version_traffic_class_and_flow_label)
1076 // Bad encap packet.
1077 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
1082 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
1084 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1089 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1094 clib_memcpy_fast (ip6srv, &sm->cache_hdr,
1095 sizeof (ip6_header_t));
1097 ip6srv->ip.dst_address = seg;
1099 if (PREDICT_FALSE (gtpu_type != GTPU_TYPE_GTPU))
1101 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
1103 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1106 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1108 ip6srv->sr.segments_left = 0;
1109 ip6srv->sr.last_entry = 0;
1111 ip6srv->sr.length = sizeof (ip6_address_t) / 8;
1112 ip6srv->sr.segments[0] = seg;
1116 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
1118 if ((clib_net_to_host_u32
1119 (encap->ip_version_traffic_class_and_flow_label)
1121 ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
1123 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
1125 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
1127 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
1128 if ((clib_net_to_host_u32
1129 (encap->ip_version_traffic_class_and_flow_label)
1132 // Bad encap packet.
1133 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
1138 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
1140 ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
1141 if ((clib_net_to_host_u32
1142 (encap->ip_version_traffic_class_and_flow_label)
1145 // Bad encap packet.
1146 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
1151 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
1153 ip6srv->ip.protocol = IP_PROTOCOL_IP6_ETHERNET;
1158 ip6srv->ip.src_address = src6;
1160 if (PREDICT_FALSE (ie_size))
1163 user_plane_sub_tlv_t *sub_tlv;
1166 (ip6_sr_tlv_t *) ((u8 *) ip6srv + (hdr_len - tlv_siz));
1167 tlv->type = SRH_TLV_USER_PLANE_CONTAINER;
1168 tlv->length = (u8) (tlv_siz - sizeof (ip6_sr_tlv_t));
1169 clib_memset (tlv->value, 0, tlv->length);
1171 sub_tlv = (user_plane_sub_tlv_t *) tlv->value;
1172 sub_tlv->type = USER_PLANE_SUB_TLV_IE;
1173 sub_tlv->length = (u8) ie_size;
1174 clib_memcpy_fast (sub_tlv->value, ie_buf, ie_size);
1176 ip6srv->sr.length += (u8) (tlv_siz / 8);
1179 ip6srv->ip.payload_length =
1180 clib_host_to_net_u16 (len0 + hdr_len - sizeof (ip6_header_t));
1184 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
1185 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1187 srv6_end_rewrite_trace_t *tr =
1188 vlib_add_trace (vm, node, b0, sizeof (*tr));
1189 clib_memcpy (tr->src.as_u8, ip6srv->ip.src_address.as_u8,
1190 sizeof (tr->src.as_u8));
1191 clib_memcpy (tr->dst.as_u8, ip6srv->ip.dst_address.as_u8,
1192 sizeof (tr->dst.as_u8));
1197 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1198 n_left_to_next, bi0, next0);
1201 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1204 vlib_node_increment_counter (vm, sm->t_m_gtp4_d_node_index,
1205 SRV6_T_ERROR_M_GTP4_D_BAD_PACKETS, bad_n);
1207 vlib_node_increment_counter (vm, sm->t_m_gtp4_d_node_index,
1208 SRV6_T_ERROR_M_GTP4_D_PACKETS, good_n);
1210 return frame->n_vectors;
1213 VLIB_REGISTER_NODE (srv6_end_m_gtp4_e) =
1215 .name = "srv6-end-m-gtp4-e",.vector_size = sizeof (u32),.format_trace =
1216 format_srv6_end_rewrite_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
1217 ARRAY_LEN (srv6_end_error_v4_strings),.error_strings =
1218 srv6_end_error_v4_strings,.n_next_nodes =
1219 SRV6_END_M_GTP4_E_N_NEXT,.next_nodes =
1221 [SRV6_END_M_GTP4_E_NEXT_DROP] =
1222 "error-drop",[SRV6_END_M_GTP4_E_NEXT_LOOKUP] = "ip4-lookup",}
1225 VLIB_REGISTER_NODE (srv6_t_m_gtp4_d) =
1227 .name = "srv6-t-m-gtp4-d",.vector_size = sizeof (u32),.format_trace =
1228 format_srv6_end_rewrite_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
1229 ARRAY_LEN (srv6_t_error_v4_d_strings),.error_strings =
1230 srv6_t_error_v4_d_strings,.n_next_nodes =
1231 SRV6_T_M_GTP4_D_N_NEXT,.next_nodes =
1233 [SRV6_T_M_GTP4_D_NEXT_DROP] =
1234 "error-drop",[SRV6_T_M_GTP4_D_NEXT_LOOKUP] = "ip6-lookup",}
1237 // Function for SRv6 GTP6.E function
1238 VLIB_NODE_FN (srv6_end_m_gtp6_e) (vlib_main_t * vm,
1239 vlib_node_runtime_t * node,
1240 vlib_frame_t * frame)
1242 srv6_end_main_v6_t *sm = &srv6_end_main_v6;
1243 ip6_sr_main_t *sm2 = &sr_main;
1244 u32 n_left_from, next_index, *from, *to_next;
1245 u32 thread_index = vm->thread_index;
1247 u32 good_n = 0, bad_n = 0;
1249 from = vlib_frame_vector_args (frame);
1250 n_left_from = frame->n_vectors;
1251 next_index = node->cached_next_index;
1253 while (n_left_from > 0)
1257 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1259 while (n_left_from > 0 && n_left_to_next > 0)
1263 ip6_sr_localsid_t *ls0;
1265 ip6srv_combo_header_t *ip6srv0;
1266 ip6_address_t dst0, src0, seg0;
1268 ip6_gtpu_header_t *hdr0 = NULL;
1276 u32 next0 = SRV6_END_M_GTP6_E_NEXT_LOOKUP;
1284 n_left_to_next -= 1;
1286 b0 = vlib_get_buffer (vm, bi0);
1288 pool_elt_at_index (sm2->localsids,
1289 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1291 ip6srv0 = vlib_buffer_get_current (b0);
1292 dst0 = ip6srv0->ip.dst_address;
1293 src0 = ip6srv0->ip.src_address;
1294 seg0 = ip6srv0->sr.segments[0];
1296 tag = ip6srv0->sr.tag;
1298 len0 = vlib_buffer_length_in_chain (vm, b0);
1300 if ((ip6srv0->ip.protocol != IPPROTO_IPV6_ROUTE)
1302 sizeof (ip6srv_combo_header_t) + 8 * ip6srv0->sr.length))
1304 next0 = SRV6_END_M_GTP6_E_NEXT_DROP;
1310 // we need to be sure there is enough space before
1311 // ip6srv0 header, there is some extra space
1312 // in the pre_data area for this kind of
1316 u8 *teid8p = (u8 *) & teid;
1324 u8 ie_buf[GTPU_IE_MAX_SIZ];
1326 index = ls0->localsid_prefix_len;
1330 gtpu_type = gtpu_type_get (tag);
1332 if (PREDICT_TRUE (shift == 0))
1334 qfi = dst0.as_u8[offset];
1336 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1337 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1338 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1340 clib_memcpy_fast (&seq, &dst0.as_u8[offset + 1], 2);
1344 clib_memcpy_fast (teid8p, &dst0.as_u8[offset + 1], 4);
1351 qfi |= dst0.as_u8[offset] << shift;
1352 qfi |= dst0.as_u8[offset + 1] >> (8 - shift);
1354 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1355 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1356 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1359 for (index = 0; index < 2; index++)
1361 sp[index] = dst0.as_u8[offset + index + 1] << shift;
1363 dst0.as_u8[offset + index + 2] >> (8 - shift);
1368 for (index = 0; index < 4; index++)
1370 *teid8p = dst0.as_u8[offset + index + 1] << shift;
1372 dst0.as_u8[offset + index + 2] >> (8 - shift);
1381 sizeof (gtpu_exthdr_t) + sizeof (gtpu_pdu_session_t);
1383 else if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1384 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1385 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1387 hdrlen = sizeof (gtpu_exthdr_t);
1390 if (gtpu_type == GTPU_TYPE_ECHO_REPLY)
1392 hdrlen += sizeof (gtpu_recovery_ie);
1395 if (PREDICT_FALSE (gtpu_type == GTPU_TYPE_ERROR_INDICATION))
1400 ext_len = ip6srv0->sr.length * 8;
1403 sizeof (ip6_address_t) * (ip6srv0->sr.last_entry + 1))
1406 (ip6_sr_tlv_t *) ((u8 *) & ip6srv0->sr +
1407 sizeof (ip6_sr_header_t) +
1408 sizeof (ip6_address_t) *
1409 (ip6srv0->sr.last_entry + 1));
1411 if (tlv->type == SRH_TLV_USER_PLANE_CONTAINER)
1413 user_plane_sub_tlv_t *sub_tlv;
1415 sub_tlv = (user_plane_sub_tlv_t *) tlv->value;
1417 ie_size = sub_tlv->length;
1418 clib_memcpy_fast (ie_buf, sub_tlv->value, ie_size);
1425 vlib_buffer_advance (b0,
1426 (word) sizeof (ip6srv_combo_header_t) +
1427 ip6srv0->sr.length * 8);
1429 // get length of encapsulated IPv6 packet (the remaining part)
1430 p = vlib_buffer_get_current (b0);
1432 plen = len0 = vlib_buffer_length_in_chain (vm, b0);
1436 hdrlen += sizeof (ip6_gtpu_header_t);
1438 vlib_buffer_advance (b0, -(word) hdrlen);
1440 hdr0 = vlib_buffer_get_current (b0);
1442 clib_memcpy_fast (hdr0, &sm->cache_hdr,
1443 sizeof (ip6_gtpu_header_t));
1445 hdr0->gtpu.teid = teid;
1446 hdr0->gtpu.length = clib_host_to_net_u16 (len0);
1448 hdr0->gtpu.type = gtpu_type;
1453 gtpu_pdu_session_t *sess;
1455 hdr0->gtpu.ver_flags |= GTPU_EXTHDR_FLAG;
1457 hdr0->gtpu.ext->seq = 0;
1458 hdr0->gtpu.ext->npdu_num = 0;
1459 hdr0->gtpu.ext->nextexthdr = GTPU_EXTHDR_PDU_SESSION;
1461 type = qfi & SRV6_PDU_SESSION_U_BIT_MASK;
1464 ((qfi & SRV6_PDU_SESSION_QFI_MASK) >> 2) |
1465 ((qfi & SRV6_PDU_SESSION_R_BIT_MASK) << 5);
1468 (gtpu_pdu_session_t *) (((char *) hdr0) +
1469 sizeof (ip6_gtpu_header_t) +
1470 sizeof (gtpu_exthdr_t));
1471 sess->exthdrlen = 1;
1475 sess->nextexthdr = 0;
1478 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1479 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1480 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1482 hdr0->gtpu.ver_flags |= GTPU_SEQ_FLAG;
1483 hdr0->gtpu.ext->seq = seq;
1484 hdr0->gtpu.ext->npdu_num = 0;
1485 hdr0->gtpu.ext->nextexthdr = 0;
1487 if (gtpu_type == GTPU_TYPE_ECHO_REPLY)
1489 gtpu_recovery_ie *recovery;
1492 (gtpu_recovery_ie *) ((u8 *) hdr0 +
1494 sizeof (gtpu_recovery_ie)));
1495 recovery->type = GTPU_RECOVERY_IE_TYPE;
1496 recovery->restart_counter = 0;
1498 else if (gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1504 ie_ptr = (u8 *) ((u8 *) hdr0 + (hdrlen - ie_size));
1505 clib_memcpy_fast (ie_ptr, ie_buf, ie_size);
1510 hdr0->udp.length = clib_host_to_net_u16 (len0 +
1511 sizeof (udp_header_t) +
1515 clib_memcpy_fast (hdr0->ip6.src_address.as_u8, src0.as_u8,
1516 sizeof (ip6_address_t));
1517 clib_memcpy_fast (hdr0->ip6.dst_address.as_u8, &seg0.as_u8,
1518 sizeof (ip6_address_t));
1520 hdr0->ip6.payload_length = clib_host_to_net_u16 (len0 +
1528 key = hash_memory (p, plen < 40 ? plen : 40, 0);
1529 port = hash_uword_to_u16 (&key);
1530 hdr0->udp.src_port = port;
1534 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
1535 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1537 srv6_end_rewrite_trace_t *tr =
1538 vlib_add_trace (vm, node, b0, sizeof (*tr));
1539 clib_memcpy (tr->src.as_u8, hdr0->ip6.src_address.as_u8,
1540 sizeof (ip6_address_t));
1541 clib_memcpy (tr->dst.as_u8, hdr0->ip6.dst_address.as_u8,
1542 sizeof (ip6_address_t));
1543 tr->teid = hdr0->gtpu.teid;
1547 vlib_increment_combined_counter
1549 SRV6_END_M_GTP6_E_NEXT_DROP) ? &(sm2->sr_ls_invalid_counters) :
1550 &(sm2->sr_ls_valid_counters)), thread_index,
1551 ls0 - sm2->localsids, 1, vlib_buffer_length_in_chain (vm, b0));
1553 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1554 n_left_to_next, bi0, next0);
1557 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1560 vlib_node_increment_counter (vm, sm->end_m_gtp6_e_node_index,
1561 SRV6_END_ERROR_M_GTP6_E_BAD_PACKETS, bad_n);
1563 vlib_node_increment_counter (vm, sm->end_m_gtp6_e_node_index,
1564 SRV6_END_ERROR_M_GTP6_E_PACKETS, good_n);
1566 return frame->n_vectors;
1569 // Function for SRv6 GTP6.D function
1570 VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm,
1571 vlib_node_runtime_t * node,
1572 vlib_frame_t * frame)
1574 srv6_end_main_v6_decap_t *sm = &srv6_end_main_v6_decap;
1575 ip6_sr_main_t *sm2 = &sr_main;
1576 u32 n_left_from, next_index, *from, *to_next;
1577 u32 thread_index = vm->thread_index;
1579 u32 good_n = 0, bad_n = 0;
1581 from = vlib_frame_vector_args (frame);
1582 n_left_from = frame->n_vectors;
1583 next_index = node->cached_next_index;
1585 while (n_left_from > 0)
1589 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1591 while (n_left_from > 0 && n_left_to_next > 0)
1595 ip6_sr_localsid_t *ls0;
1596 srv6_end_gtp6_param_t *ls_param;
1598 ip6_gtpu_header_t *hdr0 = NULL;
1601 ip6_address_t seg0, src0;
1611 ip6_header_t *encap = NULL;
1612 gtpu_pdu_session_t *sess = NULL;
1615 u8 ie_buf[GTPU_IE_MAX_SIZ];
1617 u32 next0 = SRV6_END_M_GTP6_D_NEXT_LOOKUP;
1625 n_left_to_next -= 1;
1627 b0 = vlib_get_buffer (vm, bi0);
1629 pool_elt_at_index (sm2->localsids,
1630 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1632 ls_param = (srv6_end_gtp6_param_t *) ls0->plugin_mem;
1634 hdr0 = vlib_buffer_get_current (b0);
1636 hdrlen = sizeof (ip6_gtpu_header_t);
1638 len0 = vlib_buffer_length_in_chain (vm, b0);
1640 if ((hdr0->ip6.protocol != IP_PROTOCOL_UDP)
1641 || (hdr0->udp.dst_port !=
1642 clib_host_to_net_u16 (SRV6_GTP_UDP_DST_PORT))
1643 || (len0 < sizeof (ip6_gtpu_header_t)))
1645 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1651 seg0 = ls_param->sr_prefix;
1652 src0 = hdr0->ip6.src_address;
1654 gtpu_type = hdr0->gtpu.type;
1656 teid = hdr0->gtpu.teid;
1657 teidp = (u8 *) & teid;
1659 seqp = (u8 *) & seq;
1661 if (hdr0->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
1663 // Extention header.
1664 hdrlen += sizeof (gtpu_exthdr_t);
1666 seq = hdr0->gtpu.ext->seq;
1668 if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
1670 // PDU Session Container.
1672 (gtpu_pdu_session_t *) (((char *) hdr0) +
1673 sizeof (ip6_gtpu_header_t) +
1674 sizeof (gtpu_exthdr_t));
1675 qfi = sess->u.val & ~GTPU_PDU_SESSION_P_BIT_MASK;
1676 qfip = (u8 *) & qfi;
1678 hdrlen += sizeof (gtpu_pdu_session_t);
1680 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
1682 hdrlen += sizeof (gtpu_paging_policy_t);
1687 offset = ls_param->sr_prefixlen / 8;
1688 shift = ls_param->sr_prefixlen % 8;
1690 if (PREDICT_TRUE (shift == 0))
1692 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1693 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1694 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1696 clib_memcpy_fast (&seg0.as_u8[offset + 1], seqp, 2);
1700 clib_memcpy_fast (&seg0.as_u8[offset + 1], teidp, 4);
1706 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
1707 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
1711 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
1714 seg0.as_u8[offset] = qfi;
1721 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1722 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1723 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1725 for (idx = 0; idx < 2; idx++)
1727 seg0.as_u8[offset + idx + 1] |= seqp[idx] >> shift;
1728 seg0.as_u8[offset + idx + 2] |=
1729 seqp[idx] << (8 - shift);
1734 for (idx = 0; idx < 4; idx++)
1736 seg0.as_u8[offset + idx + 1] |= teidp[idx] >> shift;
1737 seg0.as_u8[offset + idx + 2] |=
1738 teidp[idx] << (8 - shift);
1745 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
1746 ((qfi & ~GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
1750 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
1753 seg0.as_u8[offset] |= qfi >> shift;
1754 seg0.as_u8[offset + 1] |= qfi << (8 - shift);
1758 if (PREDICT_FALSE (gtpu_type == GTPU_TYPE_ERROR_INDICATION))
1762 payload_len = clib_net_to_host_u16 (hdr0->gtpu.length);
1763 if (payload_len != 0)
1766 payload_len - (hdrlen - sizeof (ip6_gtpu_header_t));
1771 ies = (u8 *) ((u8 *) hdr0 + hdrlen);
1772 clib_memcpy_fast (ie_buf, ies, ie_size);
1778 // jump over variable length data
1779 vlib_buffer_advance (b0, (word) hdrlen);
1781 // get length of encapsulated IPv6 packet (the remaining part)
1782 len0 = vlib_buffer_length_in_chain (vm, b0);
1784 if (PREDICT_TRUE (gtpu_type == GTPU_TYPE_GTPU))
1786 encap = vlib_buffer_get_current (b0);
1790 ip6srv_combo_header_t *ip6srv;
1791 ip6_sr_policy_t *sr_policy = NULL;
1792 ip6_sr_sl_t *sl = NULL;
1797 mhash_get (&sm2->sr_policies_index_hash,
1798 &ls_param->sr_prefix);
1801 sr_policy = pool_elt_at_index (sm2->sr_policies, p[0]);
1806 vec_foreach (sl_index, sr_policy->segments_lists)
1808 sl = pool_elt_at_index (sm2->sid_lists, *sl_index);
1816 hdr_len = sizeof (ip6srv_combo_header_t);
1817 hdr_len += vec_len (sl->segments) * sizeof (ip6_address_t);
1818 hdr_len += sizeof (ip6_address_t);
1822 hdr_len = sizeof (ip6_header_t);
1823 if (PREDICT_FALSE (gtpu_type) != GTPU_TYPE_GTPU)
1825 hdr_len += sizeof (ip6_sr_header_t);
1826 hdr_len += sizeof (ip6_address_t);
1833 sizeof (ip6_sr_tlv_t) + sizeof (user_plane_sub_tlv_t) +
1836 tlv_siz = (tlv_siz & ~0x07) + (tlv_siz & 0x07 ? 0x08 : 0x0);
1840 // jump back to data[0] or pre_data if required
1841 vlib_buffer_advance (b0, -(word) hdr_len);
1843 ip6srv = vlib_buffer_get_current (b0);
1847 clib_memcpy_fast (ip6srv, sl->rewrite,
1848 vec_len (sl->rewrite));
1850 if (vec_len (sl->segments) > 1)
1852 ip6srv->ip.src_address = src0;
1855 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1857 ip6srv->sr.segments_left += 1;
1858 ip6srv->sr.last_entry += 1;
1860 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
1861 ip6srv->sr.segments[0] = seg0;
1863 clib_memcpy_fast (&ip6srv->sr.segments[1],
1864 (u8 *) (sl->rewrite +
1865 sizeof (ip6_header_t) +
1866 sizeof (ip6_sr_header_t)),
1867 vec_len (sl->segments) *
1868 sizeof (ip6_address_t));
1872 ip6srv->ip.src_address = src0;
1873 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
1875 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
1876 ip6srv->sr.segments_left = 1;
1877 ip6srv->sr.last_entry = 0;
1879 ((sizeof (ip6_sr_header_t) +
1880 sizeof (ip6_address_t)) / 8) - 1;
1881 ip6srv->sr.flags = 0;
1884 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1886 ip6srv->sr.segments[0] = seg0;
1888 if (vec_len (sl->segments))
1890 ip6srv->sr.segments[1] = sl->segments[0];
1891 ip6srv->sr.last_entry++;
1892 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
1896 if (PREDICT_TRUE (encap != NULL))
1898 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
1900 if ((clib_net_to_host_u32
1901 (encap->ip_version_traffic_class_and_flow_label)
1903 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
1905 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
1907 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
1909 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
1910 if ((clib_net_to_host_u32
1911 (encap->ip_version_traffic_class_and_flow_label)
1914 // Bad encap packet.
1915 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1920 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
1922 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
1923 if ((clib_net_to_host_u32
1924 (encap->ip_version_traffic_class_and_flow_label)
1927 // Bad encap packet.
1928 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1933 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
1935 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1940 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1945 clib_memcpy_fast (ip6srv, &sm->cache_hdr,
1946 sizeof (ip6_header_t));
1948 ip6srv->ip.src_address = src0;
1949 ip6srv->ip.dst_address = seg0;
1951 if (PREDICT_FALSE (gtpu_type) != GTPU_TYPE_GTPU)
1953 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
1955 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1958 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1960 ip6srv->sr.segments_left = 0;
1961 ip6srv->sr.last_entry = 0;
1963 ip6srv->sr.length = sizeof (ip6_address_t) / 8;
1964 ip6srv->sr.segments[0] = seg0;
1968 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
1970 if ((clib_net_to_host_u32
1971 (encap->ip_version_traffic_class_and_flow_label)
1973 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
1975 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
1977 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
1978 if ((clib_net_to_host_u32
1979 (encap->ip_version_traffic_class_and_flow_label)
1982 // Bad encap packet.
1983 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1988 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
1990 ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
1991 if ((clib_net_to_host_u32
1992 (encap->ip_version_traffic_class_and_flow_label)
1995 // Bad encap packet.
1996 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
2001 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
2003 ip6srv->ip.protocol = IP_PROTOCOL_IP6_ETHERNET;
2008 if (PREDICT_FALSE (ie_size))
2011 user_plane_sub_tlv_t *sub_tlv;
2014 (ip6_sr_tlv_t *) ((u8 *) ip6srv + (hdr_len - tlv_siz));
2015 tlv->type = SRH_TLV_USER_PLANE_CONTAINER;
2016 tlv->length = (u8) (tlv_siz - sizeof (ip6_sr_tlv_t));
2017 clib_memset (tlv->value, 0, tlv->length);
2019 sub_tlv = (user_plane_sub_tlv_t *) tlv->value;
2020 sub_tlv->type = USER_PLANE_SUB_TLV_IE;
2021 sub_tlv->length = (u8) ie_size;
2022 clib_memcpy_fast (sub_tlv->value, ie_buf, ie_size);
2024 ip6srv->sr.length += (u8) (tlv_siz / 8);
2027 ip6srv->ip.payload_length =
2028 clib_host_to_net_u16 (len0 + hdr_len - sizeof (ip6_header_t));
2032 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
2033 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2035 srv6_end_rewrite_trace_t *tr =
2036 vlib_add_trace (vm, node, b0, sizeof (*tr));
2037 clib_memcpy (tr->src.as_u8, ip6srv->ip.src_address.as_u8,
2038 sizeof (ip6_address_t));
2039 clib_memcpy (tr->dst.as_u8, ip6srv->ip.dst_address.as_u8,
2040 sizeof (ip6_address_t));
2042 clib_memcpy (tr->sr_prefix.as_u8, ls_param->sr_prefix.as_u8,
2043 sizeof (ip6_address_t));
2044 tr->sr_prefixlen = ls_param->sr_prefixlen;
2049 vlib_increment_combined_counter
2051 SRV6_END_M_GTP6_D_NEXT_DROP) ? &(sm2->sr_ls_invalid_counters) :
2052 &(sm2->sr_ls_valid_counters)), thread_index,
2053 ls0 - sm2->localsids, 1, vlib_buffer_length_in_chain (vm, b0));
2055 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2056 n_left_to_next, bi0, next0);
2059 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2062 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_node_index,
2063 SRV6_END_ERROR_M_GTP6_D_BAD_PACKETS, bad_n);
2065 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_node_index,
2066 SRV6_END_ERROR_M_GTP6_D_PACKETS, good_n);
2068 return frame->n_vectors;
2071 // Function for SRv6 GTP6.D.DI function
2072 VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm,
2073 vlib_node_runtime_t * node,
2074 vlib_frame_t * frame)
2076 srv6_end_main_v6_decap_di_t *sm = &srv6_end_main_v6_decap_di;
2077 ip6_sr_main_t *sm2 = &sr_main;
2078 u32 n_left_from, next_index, *from, *to_next;
2079 u32 thread_index = vm->thread_index;
2080 srv6_end_gtp6_param_t *ls_param;
2082 u32 good_n = 0, bad_n = 0;
2084 from = vlib_frame_vector_args (frame);
2085 n_left_from = frame->n_vectors;
2086 next_index = node->cached_next_index;
2088 while (n_left_from > 0)
2092 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2094 while (n_left_from > 0 && n_left_to_next > 0)
2098 ip6_sr_localsid_t *ls0;
2100 ip6_gtpu_header_t *hdr0 = NULL;
2115 ip6_header_t *encap = NULL;
2116 gtpu_pdu_session_t *sess;
2119 u8 ie_buf[GTPU_IE_MAX_SIZ];
2121 u32 next0 = SRV6_END_M_GTP6_D_DI_NEXT_LOOKUP;
2129 n_left_to_next -= 1;
2131 b0 = vlib_get_buffer (vm, bi0);
2133 pool_elt_at_index (sm2->localsids,
2134 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
2136 ls_param = (srv6_end_gtp6_param_t *) ls0->plugin_mem;
2138 hdr0 = vlib_buffer_get_current (b0);
2140 hdrlen = sizeof (ip6_gtpu_header_t);
2142 len0 = vlib_buffer_length_in_chain (vm, b0);
2144 if ((hdr0->ip6.protocol != IP_PROTOCOL_UDP)
2145 || (hdr0->udp.dst_port !=
2146 clib_host_to_net_u16 (SRV6_GTP_UDP_DST_PORT))
2147 || (len0 < sizeof (ip6_gtpu_header_t)))
2149 next0 = SRV6_END_M_GTP6_D_DI_NEXT_DROP;
2155 dst0 = hdr0->ip6.dst_address;
2156 src0 = hdr0->ip6.src_address;
2158 gtpu_type = hdr0->gtpu.type;
2160 seg0 = ls_param->sr_prefix;
2161 teid = hdr0->gtpu.teid;
2162 teidp = (u8 *) & teid;
2164 seqp = (u8 *) & seq;
2166 if (hdr0->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
2168 // Extention header.
2169 hdrlen += sizeof (gtpu_exthdr_t);
2171 seq = hdr0->gtpu.ext->seq;
2173 if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
2175 // PDU Session Container.
2177 (gtpu_pdu_session_t *) (((char *) hdr0) + hdrlen);
2178 qfi = sess->u.val & ~GTPU_PDU_SESSION_P_BIT_MASK;
2181 hdrlen += sizeof (gtpu_pdu_session_t);
2183 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
2185 hdrlen += sizeof (gtpu_paging_policy_t);
2190 offset = ls_param->sr_prefixlen / 8;
2191 shift = ls_param->sr_prefixlen % 8;
2193 if (PREDICT_TRUE (shift == 0))
2195 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
2196 || gtpu_type == GTPU_TYPE_ECHO_REPLY
2197 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
2199 clib_memcpy_fast (&seg0.as_u8[offset + 1], seqp, 2);
2203 clib_memcpy_fast (&seg0.as_u8[offset + 1], teidp, 4);
2209 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
2210 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
2214 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
2217 seg0.as_u8[offset] = qfi;
2224 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
2225 || gtpu_type == GTPU_TYPE_ECHO_REPLY
2226 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
2228 for (idx = 0; idx < 2; idx++)
2230 seg0.as_u8[offset + idx + 1] |= seqp[idx] >> shift;
2231 seg0.as_u8[offset + idx + 2] |=
2232 seqp[idx] << (8 - shift);
2237 for (idx = 0; idx < 4; idx++)
2239 seg0.as_u8[offset + idx + 1] |= teidp[idx] >> shift;
2240 seg0.as_u8[offset + idx + 2] |=
2241 teidp[idx] << (8 - shift);
2248 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
2249 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
2253 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
2256 seg0.as_u8[offset] |= qfi >> shift;
2257 seg0.as_u8[offset + 1] |= qfi << (8 - shift);
2261 if (PREDICT_FALSE (gtpu_type == GTPU_TYPE_ERROR_INDICATION))
2265 payload_len = clib_net_to_host_u16 (hdr0->gtpu.length);
2266 if (payload_len != 0)
2269 payload_len - (hdrlen - sizeof (ip6_gtpu_header_t));
2274 ies = (u8 *) ((u8 *) hdr0 + hdrlen);
2275 clib_memcpy_fast (ie_buf, ies, ie_size);
2281 // jump over variable length data
2282 vlib_buffer_advance (b0, (word) hdrlen);
2284 // get length of encapsulated IPv6 packet (the remaining part)
2285 len0 = vlib_buffer_length_in_chain (vm, b0);
2287 if (PREDICT_TRUE (gtpu_type == GTPU_TYPE_GTPU))
2289 encap = vlib_buffer_get_current (b0);
2293 ip6srv_combo_header_t *ip6srv;
2294 ip6_sr_policy_t *sr_policy = NULL;
2295 ip6_sr_sl_t *sl = NULL;
2300 mhash_get (&sm2->sr_policies_index_hash,
2301 &ls_param->sr_prefix);
2304 sr_policy = pool_elt_at_index (sm2->sr_policies, p[0]);
2309 vec_foreach (sl_index, sr_policy->segments_lists)
2311 sl = pool_elt_at_index (sm2->sid_lists, *sl_index);
2317 hdr_len = sizeof (ip6srv_combo_header_t);
2320 hdr_len += vec_len (sl->segments) * sizeof (ip6_address_t);
2322 hdr_len += sizeof (ip6_address_t) * 2;
2327 sizeof (ip6_sr_tlv_t) + sizeof (user_plane_sub_tlv_t) +
2330 tlv_siz = (tlv_siz & ~0x07) + (tlv_siz & 0x07 ? 0x08 : 0x0);
2334 // jump back to data[0] or pre_data if required
2335 vlib_buffer_advance (b0, -(word) hdr_len);
2337 ip6srv = vlib_buffer_get_current (b0);
2341 clib_memcpy_fast (ip6srv, sl->rewrite,
2342 vec_len (sl->rewrite));
2344 if (vec_len (sl->segments) > 1)
2346 ip6srv->ip.src_address = src0;
2349 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
2351 ip6srv->sr.segments_left += 2;
2352 ip6srv->sr.last_entry += 2;
2354 ip6srv->sr.length += ((sizeof (ip6_address_t) * 2) / 8);
2356 ip6srv->sr.segments[0] = dst0;
2357 ip6srv->sr.segments[1] = seg0;
2359 clib_memcpy_fast (&ip6srv->sr.segments[2],
2360 (u8 *) (sl->rewrite +
2361 sizeof (ip6_header_t) +
2362 sizeof (ip6_sr_header_t)),
2363 vec_len (sl->segments) *
2364 sizeof (ip6_address_t));
2368 ip6srv->ip.src_address = src0;
2369 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
2371 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
2372 ip6srv->sr.segments_left = 2;
2373 ip6srv->sr.last_entry = 1;
2375 ((sizeof (ip6_sr_header_t) +
2376 2 * sizeof (ip6_address_t)) / 8) - 1;
2377 ip6srv->sr.flags = 0;
2380 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
2382 ip6srv->sr.segments[0] = dst0;
2383 ip6srv->sr.segments[1] = seg0;
2385 if (vec_len (sl->segments))
2387 ip6srv->sr.segments[2] = sl->segments[0];
2388 ip6srv->sr.last_entry++;
2389 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
2395 clib_memcpy_fast (ip6srv, &sm->cache_hdr,
2396 sizeof (ip6_header_t));
2398 ip6srv->ip.src_address = src0;
2399 ip6srv->ip.dst_address = seg0;
2401 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
2402 ip6srv->sr.segments_left = 1;
2403 ip6srv->sr.last_entry = 0;
2405 ((sizeof (ip6_sr_header_t) +
2406 sizeof (ip6_address_t)) / 8) - 1;
2407 ip6srv->sr.flags = 0;
2410 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
2412 ip6srv->sr.segments[0] = dst0;
2415 if (PREDICT_FALSE (ie_size))
2418 user_plane_sub_tlv_t *sub_tlv;
2421 (ip6_sr_tlv_t *) ((u8 *) ip6srv + (hdr_len - tlv_siz));
2422 tlv->type = SRH_TLV_USER_PLANE_CONTAINER;
2423 tlv->length = (u8) (tlv_siz - sizeof (ip6_sr_tlv_t));
2424 clib_memset (tlv->value, 0, tlv->length);
2426 sub_tlv = (user_plane_sub_tlv_t *) tlv->value;
2427 sub_tlv->length = (u8) (ie_size);
2428 clib_memcpy_fast (sub_tlv->value, ie_buf, ie_size);
2430 ip6srv->sr.length += (u8) (tlv_siz / 8);
2433 ip6srv->ip.payload_length =
2434 clib_host_to_net_u16 (len0 + hdr_len - sizeof (ip6_header_t));
2435 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
2437 if (PREDICT_TRUE (encap != NULL))
2439 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
2441 if ((clib_net_to_host_u32
2442 (encap->ip_version_traffic_class_and_flow_label) >>
2444 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
2446 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
2448 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
2450 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
2451 if ((clib_net_to_host_u32
2452 (encap->ip_version_traffic_class_and_flow_label) >>
2455 // Bad encap packet.
2456 next0 = SRV6_END_M_GTP6_D_DI_NEXT_DROP;
2461 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
2463 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
2464 if ((clib_net_to_host_u32
2465 (encap->ip_version_traffic_class_and_flow_label) >>
2468 // Bad encap packet.
2469 next0 = SRV6_END_M_GTP6_D_DI_NEXT_DROP;
2474 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
2476 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
2481 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
2486 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
2487 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2489 srv6_end_rewrite_trace_t *tr =
2490 vlib_add_trace (vm, node, b0, sizeof (*tr));
2491 clib_memcpy (tr->src.as_u8, ip6srv->ip.src_address.as_u8,
2492 sizeof (ip6_address_t));
2493 clib_memcpy (tr->dst.as_u8, ip6srv->ip.dst_address.as_u8,
2494 sizeof (ip6_address_t));
2496 clib_memcpy (tr->sr_prefix.as_u8, ls_param->sr_prefix.as_u8,
2497 sizeof (ip6_address_t));
2498 tr->sr_prefixlen = ls_param->sr_prefixlen;
2503 vlib_increment_combined_counter
2505 SRV6_END_M_GTP6_D_DI_NEXT_DROP) ?
2506 &(sm2->sr_ls_invalid_counters) : &(sm2->sr_ls_valid_counters)),
2507 thread_index, ls0 - sm2->localsids, 1,
2508 vlib_buffer_length_in_chain (vm, b0));
2510 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2511 n_left_to_next, bi0, next0);
2514 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2517 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_di_node_index,
2518 SRV6_END_ERROR_M_GTP6_D_DI_BAD_PACKETS, bad_n);
2520 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_di_node_index,
2521 SRV6_END_ERROR_M_GTP6_D_DI_PACKETS, good_n);
2523 return frame->n_vectors;
2526 // Function for SRv6 GTP6.DT function
2527 VLIB_NODE_FN (srv6_end_m_gtp6_dt) (vlib_main_t * vm,
2528 vlib_node_runtime_t * node,
2529 vlib_frame_t * frame)
2531 srv6_end_main_v6_dt_t *sm = &srv6_end_main_v6_dt;
2532 ip6_sr_main_t *sm2 = &sr_main;
2533 u32 n_left_from, next_index, *from, *to_next;
2534 u32 thread_index = vm->thread_index;
2536 u32 good_n = 0, bad_n = 0;
2538 from = vlib_frame_vector_args (frame);
2539 n_left_from = frame->n_vectors;
2540 next_index = node->cached_next_index;
2542 while (n_left_from > 0)
2546 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2548 while (n_left_from > 0 && n_left_to_next > 0)
2552 srv6_end_gtp6_dt_param_t *ls_param;
2553 ip6_sr_localsid_t *ls0;
2555 ip6_gtpu_header_t *hdr0 = NULL;
2556 ip4_header_t *ip4 = NULL;
2557 ip6_header_t *ip6 = NULL;
2558 ip6_address_t src, dst;
2563 u32 next0 = SRV6_END_M_GTP6_DT_NEXT_DROP;
2570 n_left_to_next -= 1;
2572 b0 = vlib_get_buffer (vm, bi0);
2574 pool_elt_at_index (sm2->localsids,
2575 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
2577 ls_param = (srv6_end_gtp6_dt_param_t *) ls0->plugin_mem;
2579 hdr0 = vlib_buffer_get_current (b0);
2581 hdrlen = sizeof (ip6_gtpu_header_t);
2583 len0 = vlib_buffer_length_in_chain (vm, b0);
2585 if ((hdr0->ip6.protocol != IP_PROTOCOL_UDP)
2586 || (hdr0->udp.dst_port !=
2587 clib_host_to_net_u16 (SRV6_GTP_UDP_DST_PORT))
2588 || (len0 < sizeof (ip6_gtpu_header_t)))
2590 next0 = SRV6_END_M_GTP6_DT_NEXT_DROP;
2596 clib_memcpy_fast (src.as_u8, hdr0->ip6.src_address.as_u8,
2597 sizeof (ip6_address_t));
2598 clib_memcpy_fast (dst.as_u8, hdr0->ip6.dst_address.as_u8,
2599 sizeof (ip6_address_t));
2601 teid = hdr0->gtpu.teid;
2603 if (hdr0->gtpu.ver_flags & GTPU_EXTHDR_FLAG)
2605 hdrlen += sizeof (gtpu_exthdr_t);
2606 if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
2608 gtpu_pdu_session_t *sess;
2611 (gtpu_pdu_session_t *) (((char *) hdr0) +
2612 sizeof (ip6_gtpu_header_t) +
2613 sizeof (gtpu_exthdr_t));
2615 hdrlen += sizeof (gtpu_pdu_session_t);
2616 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
2618 hdrlen += sizeof (gtpu_paging_policy_t);
2623 if (ls_param->type == SRV6_GTP6_DT4)
2625 vlib_buffer_advance (b0, (word) hdrlen);
2626 ip4 = vlib_buffer_get_current (b0);
2627 if ((ip4->ip_version_and_header_length & 0xf0) != 0x40)
2629 next0 = SRV6_END_M_GTP6_DT_NEXT_DROP;
2634 next0 = SRV6_END_M_GTP6_DT_NEXT_LOOKUP4;
2635 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2636 ls_param->fib4_index;
2638 else if (ls_param->type == SRV6_GTP6_DT6)
2640 ip6 = (ip6_header_t *) ((u8 *) hdr0 + hdrlen);
2641 if ((clib_net_to_host_u32
2642 (ip6->ip_version_traffic_class_and_flow_label) >> 28)
2645 next0 = SRV6_END_M_GTP6_DT_NEXT_DROP;
2650 next0 = SRV6_END_M_GTP6_DT_NEXT_LOOKUP6;
2651 if ((ip6->dst_address.as_u8[0] == 0xff)
2652 && ((ip6->dst_address.as_u8[1] & 0xc0) == 0x80))
2654 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2655 ls_param->local_fib_index;
2659 vlib_buffer_advance (b0, (word) hdrlen);
2660 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2661 ls_param->fib6_index;
2664 else if (ls_param->type == SRV6_GTP6_DT46)
2666 ip6 = (ip6_header_t *) ((u8 *) hdr0 + hdrlen);
2667 if ((clib_net_to_host_u32
2668 (ip6->ip_version_traffic_class_and_flow_label) >> 28)
2671 next0 = SRV6_END_M_GTP6_DT_NEXT_LOOKUP6;
2672 if ((ip6->dst_address.as_u8[0] == 0xff)
2673 && ((ip6->dst_address.as_u8[1] & 0xc0) == 0x80))
2675 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2676 ls_param->local_fib_index;
2680 vlib_buffer_advance (b0, (word) hdrlen);
2681 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2682 ls_param->fib6_index;
2686 if ((clib_net_to_host_u32
2687 (ip6->ip_version_traffic_class_and_flow_label) >> 28)
2690 vlib_buffer_advance (b0, (word) hdrlen);
2691 next0 = SRV6_END_M_GTP6_DT_NEXT_LOOKUP4;
2692 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2693 ls_param->fib4_index;
2697 next0 = SRV6_END_M_GTP6_DT_NEXT_DROP;
2704 next0 = SRV6_END_M_GTP6_DT_NEXT_DROP;
2711 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
2712 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2714 srv6_end_rewrite_trace_t *tr =
2715 vlib_add_trace (vm, node, b0, sizeof (*tr));
2716 clib_memcpy (tr->src.as_u8, src.as_u8,
2717 sizeof (ip6_address_t));
2718 clib_memcpy (tr->dst.as_u8, dst.as_u8,
2719 sizeof (ip6_address_t));
2725 vlib_increment_combined_counter
2727 SRV6_END_M_GTP6_DT_NEXT_DROP) ? &(sm2->sr_ls_invalid_counters)
2728 : &(sm2->sr_ls_valid_counters)), thread_index,
2729 ls0 - sm2->localsids, 1, vlib_buffer_length_in_chain (vm, b0));
2731 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2732 n_left_to_next, bi0, next0);
2735 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2738 vlib_node_increment_counter (vm, sm->end_m_gtp6_dt_node_index,
2739 SRV6_END_ERROR_M_GTP6_DT_BAD_PACKETS, bad_n);
2741 vlib_node_increment_counter (vm, sm->end_m_gtp6_dt_node_index,
2742 SRV6_END_ERROR_M_GTP6_DT_PACKETS, good_n);
2744 return frame->n_vectors;
2747 // Function for SRv6 GTP4.DT function
2748 VLIB_NODE_FN (srv6_t_m_gtp4_dt) (vlib_main_t * vm,
2749 vlib_node_runtime_t * node,
2750 vlib_frame_t * frame)
2752 srv6_t_main_v4_dt_t *sm = &srv6_t_main_v4_dt;
2753 ip6_sr_main_t *sm2 = &sr_main;
2754 u32 n_left_from, next_index, *from, *to_next;
2756 u32 good_n = 0, bad_n = 0;
2758 from = vlib_frame_vector_args (frame);
2759 n_left_from = frame->n_vectors;
2760 next_index = node->cached_next_index;
2762 while (n_left_from > 0)
2766 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2768 while (n_left_from > 0 && n_left_to_next > 0)
2772 srv6_t_gtp4_dt_param_t *ls_param;
2775 ip4_gtpu_header_t *hdr0 = NULL;
2776 ip4_header_t *ip4 = NULL;
2777 ip6_header_t *ip6 = NULL;
2778 ip6_address_t src, dst;
2783 u32 next0 = SRV6_T_M_GTP4_DT_NEXT_DROP;
2790 n_left_to_next -= 1;
2792 b0 = vlib_get_buffer (vm, bi0);
2794 pool_elt_at_index (sm2->sid_lists,
2795 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
2797 ls_param = (srv6_t_gtp4_dt_param_t *) ls0->plugin_mem;
2799 hdr0 = vlib_buffer_get_current (b0);
2801 hdrlen = sizeof (ip4_gtpu_header_t);
2803 len0 = vlib_buffer_length_in_chain (vm, b0);
2805 if ((hdr0->ip4.protocol != IP_PROTOCOL_UDP)
2806 || (hdr0->udp.dst_port !=
2807 clib_host_to_net_u16 (SRV6_GTP_UDP_DST_PORT))
2808 || (len0 < sizeof (ip4_gtpu_header_t)))
2810 next0 = SRV6_T_M_GTP4_DT_NEXT_DROP;
2816 clib_memcpy_fast (src.as_u8, hdr0->ip4.src_address.as_u8,
2817 sizeof (ip4_address_t));
2818 clib_memcpy_fast (dst.as_u8, hdr0->ip4.dst_address.as_u8,
2819 sizeof (ip4_address_t));
2821 teid = hdr0->gtpu.teid;
2823 if (hdr0->gtpu.ver_flags & GTPU_EXTHDR_FLAG)
2825 hdrlen += sizeof (gtpu_exthdr_t);
2826 if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
2828 gtpu_pdu_session_t *sess;
2831 (gtpu_pdu_session_t *) (((char *) hdr0) +
2832 sizeof (ip6_gtpu_header_t) +
2833 sizeof (gtpu_exthdr_t));
2835 hdrlen += sizeof (gtpu_pdu_session_t);
2836 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
2838 hdrlen += sizeof (gtpu_paging_policy_t);
2843 if (ls_param->type == SRV6_GTP4_DT4)
2845 vlib_buffer_advance (b0, (word) hdrlen);
2846 ip4 = vlib_buffer_get_current (b0);
2847 if ((ip4->ip_version_and_header_length & 0xf0) != 0x40)
2849 next0 = SRV6_T_M_GTP4_DT_NEXT_DROP;
2854 next0 = SRV6_T_M_GTP4_DT_NEXT_LOOKUP4;
2855 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2856 ls_param->fib4_index;
2858 else if (ls_param->type == SRV6_GTP4_DT6)
2860 ip6 = (ip6_header_t *) ((u8 *) hdr0 + hdrlen);
2861 if ((clib_net_to_host_u32
2862 (ip6->ip_version_traffic_class_and_flow_label) >> 28)
2865 next0 = SRV6_T_M_GTP4_DT_NEXT_DROP;
2870 next0 = SRV6_T_M_GTP4_DT_NEXT_LOOKUP6;
2871 if ((ip6->dst_address.as_u8[0] == 0xff)
2872 && ((ip6->dst_address.as_u8[1] & 0xc0) == 0x80))
2874 next0 = SRV6_T_M_GTP4_DT_NEXT_LOOKUP4;
2875 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2876 ls_param->local_fib_index;
2880 vlib_buffer_advance (b0, (word) hdrlen);
2881 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2882 ls_param->fib6_index;
2885 else if (ls_param->type == SRV6_GTP4_DT46)
2887 ip6 = (ip6_header_t *) ((u8 *) hdr0 + hdrlen);
2888 if ((clib_net_to_host_u32
2889 (ip6->ip_version_traffic_class_and_flow_label) >> 28)
2892 next0 = SRV6_T_M_GTP4_DT_NEXT_LOOKUP6;
2893 if ((ip6->dst_address.as_u8[0] == 0xff)
2894 && ((ip6->dst_address.as_u8[1] & 0xc0) == 0x80))
2896 next0 = SRV6_T_M_GTP4_DT_NEXT_LOOKUP4;
2897 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2898 ls_param->local_fib_index;
2902 vlib_buffer_advance (b0, (word) hdrlen);
2903 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2904 ls_param->fib6_index;
2908 if ((clib_net_to_host_u32
2909 (ip6->ip_version_traffic_class_and_flow_label) >> 28)
2912 vlib_buffer_advance (b0, (word) hdrlen);
2913 next0 = SRV6_T_M_GTP4_DT_NEXT_LOOKUP4;
2914 vnet_buffer (b0)->sw_if_index[VLIB_TX] =
2915 ls_param->fib4_index;
2919 next0 = SRV6_T_M_GTP4_DT_NEXT_DROP;
2926 next0 = SRV6_T_M_GTP4_DT_NEXT_DROP;
2933 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
2934 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2936 srv6_end_rewrite_trace_t *tr =
2937 vlib_add_trace (vm, node, b0, sizeof (*tr));
2938 clib_memcpy (tr->src.as_u8, src.as_u8,
2939 sizeof (ip6_address_t));
2940 clib_memcpy (tr->dst.as_u8, dst.as_u8,
2941 sizeof (ip6_address_t));
2947 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2948 n_left_to_next, bi0, next0);
2951 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2954 vlib_node_increment_counter (vm, sm->t_m_gtp4_dt_node_index,
2955 SRV6_T_ERROR_M_GTP4_DT_BAD_PACKETS, bad_n);
2957 vlib_node_increment_counter (vm, sm->t_m_gtp4_dt_node_index,
2958 SRV6_T_ERROR_M_GTP4_DT_PACKETS, good_n);
2960 return frame->n_vectors;
2963 VLIB_REGISTER_NODE (srv6_end_m_gtp6_e) =
2965 .name = "srv6-end-m-gtp6-e",.vector_size = sizeof (u32),.format_trace =
2966 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
2967 ARRAY_LEN (srv6_end_error_v6_e_strings),.error_strings =
2968 srv6_end_error_v6_e_strings,.n_next_nodes =
2969 SRV6_END_M_GTP6_E_N_NEXT,.next_nodes =
2971 [SRV6_END_M_GTP6_E_NEXT_DROP] =
2972 "error-drop",[SRV6_END_M_GTP6_E_NEXT_LOOKUP] = "ip6-lookup",}
2975 VLIB_REGISTER_NODE (srv6_end_m_gtp6_d) =
2977 .name = "srv6-end-m-gtp6-d",.vector_size = sizeof (u32),.format_trace =
2978 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
2979 ARRAY_LEN (srv6_end_error_v6_d_strings),.error_strings =
2980 srv6_end_error_v6_d_strings,.n_next_nodes =
2981 SRV6_END_M_GTP6_D_N_NEXT,.next_nodes =
2983 [SRV6_END_M_GTP6_D_NEXT_DROP] =
2984 "error-drop",[SRV6_END_M_GTP6_D_NEXT_LOOKUP] = "ip6-lookup",}
2987 VLIB_REGISTER_NODE (srv6_end_m_gtp6_d_di) =
2989 .name = "srv6-end-m-gtp6-d-di",.vector_size = sizeof (u32),.format_trace =
2990 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
2991 ARRAY_LEN (srv6_end_error_v6_d_di_strings),.error_strings =
2992 srv6_end_error_v6_d_di_strings,.n_next_nodes =
2993 SRV6_END_M_GTP6_D_DI_N_NEXT,.next_nodes =
2995 [SRV6_END_M_GTP6_D_DI_NEXT_DROP] = "error-drop",
2996 [SRV6_END_M_GTP6_D_DI_NEXT_LOOKUP] = "ip6-lookup",}
2999 VLIB_REGISTER_NODE (srv6_end_m_gtp6_dt) =
3001 .name = "srv6-end-m-gtp6-dt",.vector_size = sizeof (u32),.format_trace =
3002 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
3003 ARRAY_LEN (srv6_end_error_v6_dt_strings),.error_strings =
3004 srv6_end_error_v6_dt_strings,.n_next_nodes =
3005 SRV6_END_M_GTP6_DT_N_NEXT,.next_nodes =
3007 [SRV6_END_M_GTP6_DT_NEXT_DROP] =
3009 [SRV6_END_M_GTP6_DT_NEXT_LOOKUP4]
3010 = "ip4-lookup",[SRV6_END_M_GTP6_DT_NEXT_LOOKUP6] = "ip6-lookup",}
3013 VLIB_REGISTER_NODE (srv6_t_m_gtp4_dt) =
3015 .name = "srv6-t-m-gtp4-dt",.vector_size = sizeof (u32),.format_trace =
3016 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
3017 ARRAY_LEN (srv6_t_error_v4_dt_strings),.error_strings =
3018 srv6_t_error_v4_dt_strings,.n_next_nodes =
3019 SRV6_T_M_GTP4_DT_N_NEXT,.next_nodes =
3021 [SRV6_T_M_GTP4_DT_NEXT_DROP] =
3023 [SRV6_T_M_GTP4_DT_NEXT_LOOKUP4] =
3024 "ip4-lookup",[SRV6_T_M_GTP4_DT_NEXT_LOOKUP6] = "ip6-lookup",}
3028 * fd.io coding-style-patch-verification: ON
3031 * eval: (c-set-style "gnu")