2 * Copyright (c) 2019 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")
134 #define _(sym,str) SRV6_END_ERROR_##sym,
135 foreach_srv6_end_v4_error
138 } srv6_end_error_v4_t;
142 #define _(sym,str) SRV6_T_ERROR_##sym,
143 foreach_srv6_t_v4_d_error
146 } srv6_t_error_v4_d_t;
150 #define _(sym,str) SRV6_END_ERROR_##sym,
151 foreach_srv6_end_v6_e_error
153 SRV6_END_N_V6_E_ERROR,
154 } srv6_end_error_v6_e_t;
158 #define _(sym,str) SRV6_END_ERROR_##sym,
159 foreach_srv6_end_v6_d_error
161 SRV6_END_N_V6_D_ERROR,
162 } srv6_end_error_v6_d_t;
166 #define _(sym,str) SRV6_END_ERROR_##sym,
167 foreach_srv6_end_v6_d_di_error
169 SRV6_END_N_V6_D_DI_ERROR,
170 } srv6_end_error_v6_d_di_t;
172 static char *srv6_end_error_v4_strings[] = {
173 #define _(sym,string) string,
174 foreach_srv6_end_v4_error
178 static char *srv6_t_error_v4_d_strings[] = {
179 #define _(sym,string) string,
180 foreach_srv6_t_v4_d_error
184 static char *srv6_end_error_v6_e_strings[] = {
185 #define _(sym,string) string,
186 foreach_srv6_end_v6_e_error
190 static char *srv6_end_error_v6_d_strings[] = {
191 #define _(sym,string) string,
192 foreach_srv6_end_v6_d_error
196 static char *srv6_end_error_v6_d_di_strings[] = {
197 #define _(sym,string) string,
198 foreach_srv6_end_v6_d_di_error
204 SRV6_END_M_GTP4_E_NEXT_DROP,
205 SRV6_END_M_GTP4_E_NEXT_LOOKUP,
206 SRV6_END_M_GTP4_E_N_NEXT,
207 } srv6_end_m_gtp4_e_next_t;
211 SRV6_T_M_GTP4_D_NEXT_DROP,
212 SRV6_T_M_GTP4_D_NEXT_LOOKUP,
213 SRV6_T_M_GTP4_D_N_NEXT,
214 } srv6_T_m_gtp4_d_next_t;
218 SRV6_END_M_GTP6_E_NEXT_DROP,
219 SRV6_END_M_GTP6_E_NEXT_LOOKUP,
220 SRV6_END_M_GTP6_E_N_NEXT,
221 } srv6_end_m_gtp6_e_next_t;
225 SRV6_END_M_GTP6_D_NEXT_DROP,
226 SRV6_END_M_GTP6_D_NEXT_LOOKUP,
227 SRV6_END_M_GTP6_D_N_NEXT,
228 } srv6_end_m_gtp6_d_next_t;
232 SRV6_END_M_GTP6_D_DI_NEXT_DROP,
233 SRV6_END_M_GTP6_D_DI_NEXT_LOOKUP,
234 SRV6_END_M_GTP6_D_DI_N_NEXT,
235 } srv6_end_m_gtp6_d_di_next_t;
238 hash_uword_to_u16 (uword * key)
243 return val[0] ^ val[1] ^ val[2] ^ val[3];
245 return val[0] ^ val[1];
250 gtpu_type_get (u16 tag)
254 val = clib_net_to_host_u16 (tag);
255 if (val & SRH_TAG_ECHO_REPLY)
256 return GTPU_TYPE_ECHO_REPLY;
257 else if (val & SRH_TAG_ECHO_REQUEST)
258 return GTPU_TYPE_ECHO_REQUEST;
259 else if (val & SRH_TAG_ERROR_INDICATION)
260 return GTPU_TYPE_ERROR_INDICATION;
261 else if (val & SRH_TAG_END_MARKER)
262 return GTPU_TYPE_END_MARKER;
264 return GTPU_TYPE_GTPU;
267 // Function for SRv6 GTP4.E function.
268 VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm,
269 vlib_node_runtime_t * node,
270 vlib_frame_t * frame)
272 srv6_end_main_v4_t *sm = &srv6_end_main_v4;
273 ip6_sr_main_t *sm2 = &sr_main;
274 u32 n_left_from, next_index, *from, *to_next;
275 u32 thread_index = vm->thread_index;
277 u32 good_n = 0, bad_n = 0;
279 from = vlib_frame_vector_args (frame);
280 n_left_from = frame->n_vectors;
281 next_index = node->cached_next_index;
283 while (n_left_from > 0)
287 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
289 while (n_left_from > 0 && n_left_to_next > 0)
293 ip6_sr_localsid_t *ls0;
294 srv6_end_gtp4_param_t *ls_param;
296 ip6srv_combo_header_t *ip6srv0;
297 ip6_address_t src0, dst0;
299 ip4_gtpu_header_t *hdr0 = NULL;
302 u32 next0 = SRV6_END_M_GTP4_E_NEXT_LOOKUP;
312 b0 = vlib_get_buffer (vm, bi0);
314 pool_elt_at_index (sm2->localsids,
315 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
317 ls_param = (srv6_end_gtp4_param_t *) ls0->plugin_mem;
319 ip6srv0 = vlib_buffer_get_current (b0);
320 src0 = ip6srv0->ip.src_address;
321 dst0 = ip6srv0->ip.dst_address;
323 len0 = vlib_buffer_length_in_chain (vm, b0);
325 if ((ip6srv0->ip.protocol == IPPROTO_IPV6_ROUTE
327 sizeof (ip6srv_combo_header_t) + ip6srv0->sr.length * 8)
328 || (len0 < sizeof (ip6_header_t)))
330 next0 = SRV6_END_M_GTP4_E_NEXT_DROP;
339 u8 *teid8p = (u8 *) & teid;
350 // we need to be sure there is enough space before
351 // ip6srv0 header, there is some extra space
352 // in the pre_data area for this kind of
355 // jump over variable length data
356 // not sure about the length
357 if (ip6srv0->ip.protocol == IPPROTO_IPV6_ROUTE)
359 tag = ip6srv0->sr.tag;
361 vlib_buffer_advance (b0,
362 (word) sizeof (ip6srv_combo_header_t) +
363 ip6srv0->sr.length * 8);
367 vlib_buffer_advance (b0, (word) sizeof (ip6_header_t));
370 // get length of encapsulated IPv6 packet (the remaining part)
371 p = vlib_buffer_get_current (b0);
373 len0 = vlib_buffer_length_in_chain (vm, b0);
375 offset = ls0->localsid_prefix_len / 8;
376 shift = ls0->localsid_prefix_len % 8;
378 gtpu_type = gtpu_type_get (tag);
380 if (PREDICT_TRUE (shift == 0))
382 clib_memcpy_fast (&dst4.as_u8[0], &dst0.as_u8[offset], 4);
384 qfi = dst0.as_u8[offset + 4];
386 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
387 || gtpu_type == GTPU_TYPE_ECHO_REPLY
388 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
390 clib_memcpy_fast (&seq, &dst0.as_u8[offset + 5], 2);
394 clib_memcpy_fast (teid8p, &dst0.as_u8[offset + 5], 4);
401 for (index = 0; index < 4; index++)
403 dst4.as_u8[index] = dst0.as_u8[offset + index] << shift;
405 dst0.as_u8[offset + index + 1] >> (8 - shift);
408 qfi |= dst0.as_u8[offset + 4] << shift;
409 qfi |= dst0.as_u8[offset + 5] >> (8 - shift);
411 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
412 || gtpu_type == GTPU_TYPE_ECHO_REPLY
413 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
416 for (index = 0; index < 2; index++)
418 sp[index] = dst0.as_u8[offset + 5 + index] << shift;
420 dst0.as_u8[offset + 6 + index] >> (8 - shift);
425 for (index = 0; index < 4; index++)
427 *teid8p = dst0.as_u8[offset + 5 + index] << shift;
429 dst0.as_u8[offset + 6 + index] >> (8 - shift);
438 sizeof (gtpu_exthdr_t) + sizeof (gtpu_pdu_session_t);
440 else if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
441 || gtpu_type == GTPU_TYPE_ECHO_REPLY
442 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
444 hdrlen = sizeof (gtpu_exthdr_t);
448 hdrlen += sizeof (ip4_gtpu_header_t);
450 // IPv4 GTP-U header creation.
451 vlib_buffer_advance (b0, -(word) hdrlen);
453 hdr0 = vlib_buffer_get_current (b0);
455 clib_memcpy_fast (hdr0, &sm->cache_hdr,
456 sizeof (ip4_gtpu_header_t));
458 hdr0->ip4.dst_address.as_u32 = dst4.as_u32;
460 hdr0->gtpu.teid = teid;
461 hdr0->gtpu.length = clib_host_to_net_u16 (len0);
463 hdr0->gtpu.type = gtpu_type;
468 gtpu_pdu_session_t *sess;
470 hdr0->gtpu.ver_flags |= GTPU_EXTHDR_FLAG;
472 hdr0->gtpu.ext->seq = 0;
474 hdr0->gtpu.ext->npdu_num = 0;
475 hdr0->gtpu.ext->nextexthdr = GTPU_EXTHDR_PDU_SESSION;
477 type = qfi & SRV6_PDU_SESSION_U_BIT_MASK;
480 ((qfi & SRV6_PDU_SESSION_QFI_MASK) >> 2) |
481 ((qfi & SRV6_PDU_SESSION_R_BIT_MASK) << 5);
484 (gtpu_pdu_session_t *) (((char *) hdr0) +
485 sizeof (ip4_gtpu_header_t) +
486 sizeof (gtpu_exthdr_t));
491 sess->nextexthdr = 0;
494 if (gtpu_type == GTPU_TYPE_ECHO_REPLY
495 || gtpu_type == GTPU_TYPE_ECHO_REQUEST
496 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
498 hdr0->gtpu.ver_flags |= GTPU_SEQ_FLAG;
499 hdr0->gtpu.ext->seq = seq;
500 hdr0->gtpu.ext->npdu_num = 0;
501 hdr0->gtpu.ext->nextexthdr = 0;
504 offset = ls_param->v4src_position / 8;
505 shift = ls_param->v4src_position % 8;
507 if (PREDICT_TRUE (shift == 0))
509 for (index = 0; index < 4; index++)
511 hdr0->ip4.src_address.as_u8[index] =
512 src0.as_u8[offset + index];
517 for (index = 0; index < 4; index++)
519 hdr0->ip4.src_address.as_u8[index] =
520 src0.as_u8[offset + index] << shift;
521 hdr0->ip4.src_address.as_u8[index] |=
522 src0.as_u8[offset + index + 1] >> (8 - shift);
526 key = hash_memory (p, len0, 0);
527 port = hash_uword_to_u16 (&key);
528 hdr0->udp.src_port = port;
530 hdr0->udp.length = clib_host_to_net_u16 (len0 +
531 sizeof (udp_header_t) +
535 hdr0->ip4.length = clib_host_to_net_u16 (len0 +
537 (ip4_gtpu_header_t));
539 hdr0->ip4.checksum = ip4_header_checksum (&hdr0->ip4);
543 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
544 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
546 srv6_end_rewrite_trace_t *tr =
547 vlib_add_trace (vm, node, b0, sizeof (*tr));
548 clib_memcpy (tr->src.as_u8, hdr0->ip4.src_address.as_u8,
549 sizeof (tr->src.as_u8));
550 clib_memcpy (tr->dst.as_u8, hdr0->ip4.dst_address.as_u8,
551 sizeof (tr->dst.as_u8));
552 tr->teid = hdr0->gtpu.teid;
556 vlib_increment_combined_counter
558 SRV6_END_M_GTP4_E_NEXT_DROP) ? &(sm2->sr_ls_invalid_counters) :
559 &(sm2->sr_ls_valid_counters)), thread_index,
560 ls0 - sm2->localsids, 1, vlib_buffer_length_in_chain (vm, b0));
562 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
563 n_left_to_next, bi0, next0);
566 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
569 vlib_node_increment_counter (vm, sm->end_m_gtp4_e_node_index,
570 SRV6_END_ERROR_M_GTP4_E_BAD_PACKETS, bad_n);
572 vlib_node_increment_counter (vm, sm->end_m_gtp4_e_node_index,
573 SRV6_END_ERROR_M_GTP4_E_PACKETS, good_n);
575 return frame->n_vectors;
578 // Function for SRv6 GTP4.D function.
579 VLIB_NODE_FN (srv6_t_m_gtp4_d) (vlib_main_t * vm,
580 vlib_node_runtime_t * node,
581 vlib_frame_t * frame)
583 srv6_t_main_v4_decap_t *sm = &srv6_t_main_v4_decap;
584 ip6_sr_main_t *sm2 = &sr_main;
585 u32 n_left_from, next_index, *from, *to_next;
587 u32 good_n = 0, bad_n = 0;
589 from = vlib_frame_vector_args (frame);
590 n_left_from = frame->n_vectors;
591 next_index = node->cached_next_index;
593 while (n_left_from > 0)
597 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
599 while (n_left_from > 0 && n_left_to_next > 0)
604 srv6_end_gtp4_param_t *ls_param;
609 u32 next0 = SRV6_T_M_GTP4_D_NEXT_LOOKUP;
619 b0 = vlib_get_buffer (vm, bi0);
622 pool_elt_at_index (sm2->sid_lists,
623 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
625 ls_param = (srv6_end_gtp4_param_t *) sl0->plugin_mem;
627 len0 = vlib_buffer_length_in_chain (vm, b0);
629 ip4 = vlib_buffer_get_current (b0);
631 if (ip4->protocol != IP_PROTOCOL_UDP
632 || len0 < sizeof (ip4_gtpu_header_t))
634 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
641 ip6_sr_policy_t *sr_policy = NULL;
642 ip6_sr_sl_t *sl = NULL;
646 ip4_gtpu_header_t *hdr;
647 ip4_address_t src, dst;
649 ip6_header_t *encap = NULL;
659 u32 offset, shift, index;
660 ip6srv_combo_header_t *ip6srv;
661 gtpu_pdu_session_t *sess = NULL;
664 hdr = (ip4_gtpu_header_t *) ip4;
666 hdr_len = sizeof (ip4_gtpu_header_t);
668 teid = hdr->gtpu.teid;
669 teidp = (u8 *) & teid;
673 gtpu_type = hdr->gtpu.type;
675 if (hdr->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
678 hdr_len += sizeof (gtpu_exthdr_t);
680 seq = hdr->gtpu.ext->seq;
682 if (hdr->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
684 // PDU Session Container.
686 (gtpu_pdu_session_t *) (((char *) hdr) + hdr_len);
687 qfi = sess->u.val & ~GTPU_PDU_SESSION_P_BIT_MASK;
690 hdr_len += sizeof (gtpu_pdu_session_t);
692 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
694 hdr_len += sizeof (gtpu_paging_policy_t);
699 src = hdr->ip4.src_address;
702 dst = hdr->ip4.dst_address;
705 seg = ls_param->sr_prefix;
707 offset = ls_param->sr_prefixlen / 8;
708 shift = ls_param->sr_prefixlen % 8;
710 if (PREDICT_TRUE (shift == 0))
712 clib_memcpy_fast (&seg.as_u8[offset], dstp, 4);
717 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
718 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
722 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
725 seg.as_u8[offset + 4] = qfi;
728 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
729 || gtpu_type == GTPU_TYPE_ECHO_REPLY
730 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
732 clib_memcpy_fast (&seg.as_u8[offset + 5], seqp, 2);
736 clib_memcpy_fast (&seg.as_u8[offset + 5], teidp, 4);
741 for (index = 0; index < 4; index++)
743 seg.as_u8[offset + index] |= dstp[index] >> shift;
744 seg.as_u8[offset + index + 1] |=
745 dstp[index] << (8 - shift);
751 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
752 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
756 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
759 seg.as_u8[offset + 4] |= qfi >> shift;
760 seg.as_u8[offset + 5] |= qfi << (8 - shift);
763 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
764 || gtpu_type == GTPU_TYPE_ECHO_REPLY
765 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
767 for (index = 0; index < 2; index++)
769 seg.as_u8[offset + 5 + index] |=
770 seqp[index] >> shift;
771 seg.as_u8[offset + 6 + index] |=
772 seqp[index] << (8 - shift);
777 for (index = 0; index < 4; index++)
779 seg.as_u8[offset + index + 5] |=
780 teidp[index] >> shift;
781 seg.as_u8[offset + index + 6] |=
782 teidp[index] << (8 - shift);
787 src6 = ls_param->v6src_prefix;
789 offset = ls_param->v6src_prefixlen / 8;
790 shift = ls_param->v6src_prefixlen % 8;
792 if (PREDICT_TRUE (shift == 0))
794 clib_memcpy_fast (&src6.as_u8[offset], srcp, 4);
798 for (index = 0; index < 4; index++)
800 src6.as_u8[offset + index] |= srcp[offset] >> shift;
801 src6.as_u8[offset + index + 1] |=
802 srcp[offset] << (8 - shift);
806 vlib_buffer_advance (b0, (word) hdr_len);
809 if (PREDICT_TRUE (gtpu_type == GTPU_TYPE_GTPU))
811 encap = vlib_buffer_get_current (b0);
814 len0 = vlib_buffer_length_in_chain (vm, b0);
817 mhash_get (&sm2->sr_policies_index_hash,
818 &ls_param->sr_prefix);
821 sr_policy = pool_elt_at_index (sm2->sr_policies, p[0]);
826 vec_foreach (sl_index, sr_policy->segments_lists)
828 sl = pool_elt_at_index (sm2->sid_lists, *sl_index);
836 hdr_len = sizeof (ip6srv_combo_header_t);
837 hdr_len += vec_len (sl->segments) * sizeof (ip6_address_t);
838 hdr_len += sizeof (ip6_address_t);
842 hdr_len = sizeof (ip6_header_t);
844 if (PREDICT_FALSE (gtpu_type != GTPU_TYPE_GTPU))
846 hdr_len += sizeof (ip6_sr_header_t);
847 hdr_len += sizeof (ip6_address_t);
851 vlib_buffer_advance (b0, -(word) hdr_len);
852 ip6srv = vlib_buffer_get_current (b0);
856 clib_memcpy_fast (ip6srv, sl->rewrite,
857 vec_len (sl->rewrite));
859 if (vec_len (sl->segments) > 1)
862 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
864 ip6srv->sr.segments_left += 1;
865 ip6srv->sr.last_entry += 1;
867 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
868 ip6srv->sr.segments[0] = seg;
870 clib_memcpy_fast (&ip6srv->sr.segments[1],
871 (u8 *) (sl->rewrite +
872 sizeof (ip6_header_t) +
873 sizeof (ip6_sr_header_t)),
874 vec_len (sl->segments) *
875 sizeof (ip6_address_t));
879 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
881 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
883 ip6srv->sr.segments_left = 1;
884 ip6srv->sr.last_entry = 0;
887 ((sizeof (ip6_sr_header_t) +
888 sizeof (ip6_address_t)) / 8) - 1;
889 ip6srv->sr.flags = 0;
892 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
894 ip6srv->sr.segments[0] = seg;
895 if (vec_len (sl->segments))
897 ip6srv->sr.segments[1] = sl->segments[0];
898 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
899 ip6srv->sr.last_entry++;
903 if (PREDICT_TRUE (encap != NULL))
905 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
907 if ((clib_net_to_host_u32
908 (encap->ip_version_traffic_class_and_flow_label)
910 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
912 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
914 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
916 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
917 if ((clib_net_to_host_u32
918 (encap->ip_version_traffic_class_and_flow_label)
922 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
927 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
929 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
930 if ((clib_net_to_host_u32
931 (encap->ip_version_traffic_class_and_flow_label)
935 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
940 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
942 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
947 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
952 clib_memcpy_fast (ip6srv, &sm->cache_hdr,
953 sizeof (ip6_header_t));
955 ip6srv->ip.dst_address = seg;
957 if (PREDICT_FALSE (gtpu_type != GTPU_TYPE_GTPU))
959 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
961 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
964 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
966 ip6srv->sr.segments_left = 0;
967 ip6srv->sr.last_entry = 0;
969 ip6srv->sr.length = sizeof (ip6_address_t) / 8;
970 ip6srv->sr.segments[0] = seg;
974 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
976 if ((clib_net_to_host_u32
977 (encap->ip_version_traffic_class_and_flow_label)
979 ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
981 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
983 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
985 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
986 if ((clib_net_to_host_u32
987 (encap->ip_version_traffic_class_and_flow_label)
991 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
996 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
998 ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
999 if ((clib_net_to_host_u32
1000 (encap->ip_version_traffic_class_and_flow_label)
1003 // Bad encap packet.
1004 next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
1009 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
1011 ip6srv->ip.protocol = IP_PROTOCOL_IP6_ETHERNET;
1016 ip6srv->ip.src_address = src6;
1018 ip6srv->ip.payload_length =
1019 clib_host_to_net_u16 (len0 + hdr_len - sizeof (ip6_header_t));
1023 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
1024 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1026 srv6_end_rewrite_trace_t *tr =
1027 vlib_add_trace (vm, node, b0, sizeof (*tr));
1028 clib_memcpy (tr->src.as_u8, ip6srv->ip.src_address.as_u8,
1029 sizeof (tr->src.as_u8));
1030 clib_memcpy (tr->dst.as_u8, ip6srv->ip.dst_address.as_u8,
1031 sizeof (tr->dst.as_u8));
1036 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1037 n_left_to_next, bi0, next0);
1040 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1043 vlib_node_increment_counter (vm, sm->t_m_gtp4_d_node_index,
1044 SRV6_T_ERROR_M_GTP4_D_BAD_PACKETS, bad_n);
1046 vlib_node_increment_counter (vm, sm->t_m_gtp4_d_node_index,
1047 SRV6_T_ERROR_M_GTP4_D_PACKETS, good_n);
1049 return frame->n_vectors;
1052 VLIB_REGISTER_NODE (srv6_end_m_gtp4_e) =
1054 .name = "srv6-end-m-gtp4-e",.vector_size = sizeof (u32),.format_trace =
1055 format_srv6_end_rewrite_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
1056 ARRAY_LEN (srv6_end_error_v4_strings),.error_strings =
1057 srv6_end_error_v4_strings,.n_next_nodes =
1058 SRV6_END_M_GTP4_E_N_NEXT,.next_nodes =
1060 [SRV6_END_M_GTP4_E_NEXT_DROP] = "error-drop",
1061 [SRV6_END_M_GTP4_E_NEXT_LOOKUP] = "ip4-lookup",}
1064 VLIB_REGISTER_NODE (srv6_t_m_gtp4_d) =
1066 .name = "srv6-t-m-gtp4-d",.vector_size = sizeof (u32),.format_trace =
1067 format_srv6_end_rewrite_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
1068 ARRAY_LEN (srv6_t_error_v4_d_strings),.error_strings =
1069 srv6_t_error_v4_d_strings,.n_next_nodes =
1070 SRV6_T_M_GTP4_D_N_NEXT,.next_nodes =
1072 [SRV6_T_M_GTP4_D_NEXT_DROP] = "error-drop",
1073 [SRV6_T_M_GTP4_D_NEXT_LOOKUP] = "ip6-lookup",}
1076 // Function for SRv6 GTP6.E function
1077 VLIB_NODE_FN (srv6_end_m_gtp6_e) (vlib_main_t * vm,
1078 vlib_node_runtime_t * node,
1079 vlib_frame_t * frame)
1081 srv6_end_main_v6_t *sm = &srv6_end_main_v6;
1082 ip6_sr_main_t *sm2 = &sr_main;
1083 u32 n_left_from, next_index, *from, *to_next;
1084 u32 thread_index = vm->thread_index;
1086 u32 good_n = 0, bad_n = 0;
1088 from = vlib_frame_vector_args (frame);
1089 n_left_from = frame->n_vectors;
1090 next_index = node->cached_next_index;
1092 while (n_left_from > 0)
1096 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1098 while (n_left_from > 0 && n_left_to_next > 0)
1102 ip6_sr_localsid_t *ls0;
1104 ip6srv_combo_header_t *ip6srv0;
1105 ip6_address_t dst0, src0, seg0;
1107 ip6_gtpu_header_t *hdr0 = NULL;
1114 u32 next0 = SRV6_END_M_GTP6_E_NEXT_LOOKUP;
1122 n_left_to_next -= 1;
1124 b0 = vlib_get_buffer (vm, bi0);
1126 pool_elt_at_index (sm2->localsids,
1127 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1129 ip6srv0 = vlib_buffer_get_current (b0);
1130 dst0 = ip6srv0->ip.dst_address;
1131 src0 = ip6srv0->ip.src_address;
1132 seg0 = ip6srv0->sr.segments[0];
1134 tag = ip6srv0->sr.tag;
1136 len0 = vlib_buffer_length_in_chain (vm, b0);
1138 if ((ip6srv0->ip.protocol != IPPROTO_IPV6_ROUTE)
1140 sizeof (ip6srv_combo_header_t) + 8 * ip6srv0->sr.length))
1142 next0 = SRV6_END_M_GTP6_E_NEXT_DROP;
1148 // we need to be sure there is enough space before
1149 // ip6srv0 header, there is some extra space
1150 // in the pre_data area for this kind of
1153 // jump over variable length data
1154 // not sure about the length
1155 vlib_buffer_advance (b0, (word) sizeof (ip6srv_combo_header_t) +
1156 ip6srv0->sr.length * 8);
1158 // get length of encapsulated IPv6 packet (the remaining part)
1159 p = vlib_buffer_get_current (b0);
1161 len0 = vlib_buffer_length_in_chain (vm, b0);
1164 u8 *teid8p = (u8 *) & teid;
1172 index = ls0->localsid_prefix_len;
1177 gtpu_type = gtpu_type_get (tag);
1179 if (PREDICT_TRUE (shift == 0))
1181 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1182 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1183 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1185 clib_memcpy_fast (&seq, &dst0.as_u8[offset], 2);
1189 clib_memcpy_fast (teid8p, &dst0.as_u8[offset], 4);
1192 qfi = dst0.as_u8[offset + 4];
1198 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1199 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1200 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1203 for (index = 0; index < 2; index++)
1205 sp[index] = dst0.as_u8[offset + index] << shift;
1207 dst0.as_u8[offset + index + 1] >> (8 - shift);
1212 for (index = 0; index < 4; index++)
1214 *teid8p = dst0.as_u8[offset + index] << shift;
1216 dst0.as_u8[offset + index + 1] >> (8 - shift);
1221 qfi |= dst0.as_u8[offset + 4] << shift;
1222 qfi |= dst0.as_u8[offset + 5] >> (8 - shift);
1228 sizeof (gtpu_exthdr_t) + sizeof (gtpu_pdu_session_t);
1230 else if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1231 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1232 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1234 hdrlen = sizeof (gtpu_exthdr_t);
1238 hdrlen += sizeof (ip6_gtpu_header_t);
1240 vlib_buffer_advance (b0, -(word) hdrlen);
1242 hdr0 = vlib_buffer_get_current (b0);
1244 clib_memcpy_fast (hdr0, &sm->cache_hdr,
1245 sizeof (ip6_gtpu_header_t));
1247 hdr0->gtpu.teid = teid;
1248 hdr0->gtpu.length = clib_host_to_net_u16 (len0);
1250 hdr0->gtpu.type = gtpu_type;
1255 gtpu_pdu_session_t *sess;
1257 hdr0->gtpu.ver_flags |= GTPU_EXTHDR_FLAG;
1259 hdr0->gtpu.ext->seq = 0;
1260 hdr0->gtpu.ext->npdu_num = 0;
1261 hdr0->gtpu.ext->nextexthdr = GTPU_EXTHDR_PDU_SESSION;
1263 type = qfi & SRV6_PDU_SESSION_U_BIT_MASK;
1266 ((qfi & SRV6_PDU_SESSION_QFI_MASK) >> 2) |
1267 ((qfi & SRV6_PDU_SESSION_R_BIT_MASK) << 5);
1270 (gtpu_pdu_session_t *) (((char *) hdr0) +
1271 sizeof (ip6_gtpu_header_t) +
1272 sizeof (gtpu_exthdr_t));
1273 sess->exthdrlen = 1;
1277 sess->nextexthdr = 0;
1280 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1281 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1282 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1284 hdr0->gtpu.ver_flags |= GTPU_SEQ_FLAG;
1285 hdr0->gtpu.ext->seq = seq;
1286 hdr0->gtpu.ext->npdu_num = 0;
1287 hdr0->gtpu.ext->nextexthdr = 0;
1290 hdr0->udp.length = clib_host_to_net_u16 (len0 +
1291 sizeof (udp_header_t) +
1295 clib_memcpy_fast (hdr0->ip6.src_address.as_u8, src0.as_u8,
1296 sizeof (ip6_address_t));
1297 clib_memcpy_fast (hdr0->ip6.dst_address.as_u8, &seg0.as_u8,
1298 sizeof (ip6_address_t));
1300 hdr0->ip6.payload_length = clib_host_to_net_u16 (len0 +
1308 key = hash_memory (p, len0, 0);
1309 port = hash_uword_to_u16 (&key);
1310 hdr0->udp.src_port = port;
1314 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
1315 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1317 srv6_end_rewrite_trace_t *tr =
1318 vlib_add_trace (vm, node, b0, sizeof (*tr));
1319 clib_memcpy (tr->src.as_u8, hdr0->ip6.src_address.as_u8,
1320 sizeof (ip6_address_t));
1321 clib_memcpy (tr->dst.as_u8, hdr0->ip6.dst_address.as_u8,
1322 sizeof (ip6_address_t));
1323 tr->teid = hdr0->gtpu.teid;
1327 vlib_increment_combined_counter
1329 SRV6_END_M_GTP6_E_NEXT_DROP) ? &(sm2->sr_ls_invalid_counters) :
1330 &(sm2->sr_ls_valid_counters)), thread_index,
1331 ls0 - sm2->localsids, 1, vlib_buffer_length_in_chain (vm, b0));
1333 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1334 n_left_to_next, bi0, next0);
1337 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1340 vlib_node_increment_counter (vm, sm->end_m_gtp6_e_node_index,
1341 SRV6_END_ERROR_M_GTP6_E_BAD_PACKETS, bad_n);
1343 vlib_node_increment_counter (vm, sm->end_m_gtp6_e_node_index,
1344 SRV6_END_ERROR_M_GTP6_E_PACKETS, good_n);
1346 return frame->n_vectors;
1349 // Function for SRv6 GTP6.D function
1350 VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm,
1351 vlib_node_runtime_t * node,
1352 vlib_frame_t * frame)
1354 srv6_end_main_v6_decap_t *sm = &srv6_end_main_v6_decap;
1355 ip6_sr_main_t *sm2 = &sr_main;
1356 u32 n_left_from, next_index, *from, *to_next;
1357 u32 thread_index = vm->thread_index;
1359 u32 good_n = 0, bad_n = 0;
1361 from = vlib_frame_vector_args (frame);
1362 n_left_from = frame->n_vectors;
1363 next_index = node->cached_next_index;
1365 while (n_left_from > 0)
1369 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1371 while (n_left_from > 0 && n_left_to_next > 0)
1375 ip6_sr_localsid_t *ls0;
1376 srv6_end_gtp6_param_t *ls_param;
1378 ip6_gtpu_header_t *hdr0 = NULL;
1381 ip6_address_t seg0, src0;
1391 ip6_header_t *encap = NULL;
1392 gtpu_pdu_session_t *sess = NULL;
1394 u32 next0 = SRV6_END_M_GTP6_D_NEXT_LOOKUP;
1402 n_left_to_next -= 1;
1404 b0 = vlib_get_buffer (vm, bi0);
1406 pool_elt_at_index (sm2->localsids,
1407 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1409 ls_param = (srv6_end_gtp6_param_t *) ls0->plugin_mem;
1411 hdr0 = vlib_buffer_get_current (b0);
1413 hdrlen = sizeof (ip6_gtpu_header_t);
1415 len0 = vlib_buffer_length_in_chain (vm, b0);
1417 if ((hdr0->ip6.protocol != IP_PROTOCOL_UDP)
1418 || (hdr0->udp.dst_port !=
1419 clib_host_to_net_u16 (SRV6_GTP_UDP_DST_PORT))
1420 || (len0 < sizeof (ip6_gtpu_header_t)))
1422 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1428 seg0 = ls_param->sr_prefix;
1429 src0 = hdr0->ip6.src_address;
1431 gtpu_type = hdr0->gtpu.type;
1433 teid = hdr0->gtpu.teid;
1434 teidp = (u8 *) & teid;
1436 seqp = (u8 *) & seq;
1438 if (hdr0->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
1440 // Extention header.
1441 hdrlen += sizeof (gtpu_exthdr_t);
1443 seq = hdr0->gtpu.ext->seq;
1445 if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
1447 // PDU Session Container.
1449 (gtpu_pdu_session_t *) (((char *) hdr0) +
1450 sizeof (ip6_gtpu_header_t) +
1451 sizeof (gtpu_exthdr_t));
1452 qfi = sess->u.val & ~GTPU_PDU_SESSION_P_BIT_MASK;
1453 qfip = (u8 *) & qfi;
1455 hdrlen += sizeof (gtpu_pdu_session_t);
1457 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
1459 hdrlen += sizeof (gtpu_paging_policy_t);
1464 offset = ls_param->sr_prefixlen / 8;
1465 shift = ls_param->sr_prefixlen % 8;
1468 if (PREDICT_TRUE (shift == 0))
1470 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1471 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1472 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1474 clib_memcpy_fast (&seg0.as_u8[offset], seqp, 2);
1478 clib_memcpy_fast (&seg0.as_u8[offset], teidp, 4);
1484 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
1485 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
1489 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
1492 seg0.as_u8[offset + 4] = qfi;
1499 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1500 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1501 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1503 for (idx = 0; idx < 2; idx++)
1505 seg0.as_u8[offset + idx] |= seqp[idx] >> shift;
1506 seg0.as_u8[offset + idx + 1] |=
1507 seqp[idx] << (8 - shift);
1512 for (idx = 0; idx < 4; idx++)
1514 seg0.as_u8[offset + idx] |= teidp[idx] >> shift;
1515 seg0.as_u8[offset + idx + 1] |=
1516 teidp[idx] << (8 - shift);
1523 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
1524 ((qfi & ~GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
1528 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
1531 seg0.as_u8[offset + 4] |= qfi >> shift;
1532 seg0.as_u8[offset + 5] |= qfi << (8 - shift);
1536 // jump over variable length data
1537 vlib_buffer_advance (b0, (word) hdrlen);
1539 // get length of encapsulated IPv6 packet (the remaining part)
1540 len0 = vlib_buffer_length_in_chain (vm, b0);
1542 if (PREDICT_TRUE (gtpu_type == GTPU_TYPE_GTPU))
1544 encap = vlib_buffer_get_current (b0);
1548 ip6srv_combo_header_t *ip6srv;
1549 ip6_sr_policy_t *sr_policy = NULL;
1550 ip6_sr_sl_t *sl = NULL;
1555 mhash_get (&sm2->sr_policies_index_hash,
1556 &ls_param->sr_prefix);
1559 sr_policy = pool_elt_at_index (sm2->sr_policies, p[0]);
1564 vec_foreach (sl_index, sr_policy->segments_lists)
1566 sl = pool_elt_at_index (sm2->sid_lists, *sl_index);
1574 hdr_len = sizeof (ip6srv_combo_header_t);
1575 hdr_len += vec_len (sl->segments) * sizeof (ip6_address_t);
1576 hdr_len += sizeof (ip6_address_t);
1580 hdr_len = sizeof (ip6_header_t);
1581 if (PREDICT_FALSE (gtpu_type) != GTPU_TYPE_GTPU)
1583 hdr_len += sizeof (ip6_sr_header_t);
1584 hdr_len += sizeof (ip6_address_t);
1588 // jump back to data[0] or pre_data if required
1589 vlib_buffer_advance (b0, -(word) hdr_len);
1591 ip6srv = vlib_buffer_get_current (b0);
1595 clib_memcpy_fast (ip6srv, sl->rewrite,
1596 vec_len (sl->rewrite));
1598 if (vec_len (sl->segments) > 1)
1600 ip6srv->ip.src_address = src0;
1603 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1605 ip6srv->sr.segments_left += 1;
1606 ip6srv->sr.last_entry += 1;
1608 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
1609 ip6srv->sr.segments[0] = seg0;
1611 clib_memcpy_fast (&ip6srv->sr.segments[1],
1612 (u8 *) (sl->rewrite +
1613 sizeof (ip6_header_t) +
1614 sizeof (ip6_sr_header_t)),
1615 vec_len (sl->segments) *
1616 sizeof (ip6_address_t));
1620 ip6srv->ip.src_address = src0;
1621 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
1623 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
1624 ip6srv->sr.segments_left = 1;
1625 ip6srv->sr.last_entry = 0;
1627 ((sizeof (ip6_sr_header_t) +
1628 sizeof (ip6_address_t)) / 8) - 1;
1629 ip6srv->sr.flags = 0;
1632 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1634 ip6srv->sr.segments[0] = seg0;
1636 if (vec_len (sl->segments))
1638 ip6srv->sr.segments[1] = sl->segments[0];
1639 ip6srv->sr.last_entry++;
1640 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
1644 if (PREDICT_TRUE (encap != NULL))
1646 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
1648 if ((clib_net_to_host_u32
1649 (encap->ip_version_traffic_class_and_flow_label)
1651 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
1653 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
1655 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
1657 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
1658 if ((clib_net_to_host_u32
1659 (encap->ip_version_traffic_class_and_flow_label)
1662 // Bad encap packet.
1663 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1668 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
1670 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
1671 if ((clib_net_to_host_u32
1672 (encap->ip_version_traffic_class_and_flow_label)
1675 // Bad encap packet.
1676 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1681 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
1683 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1688 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1693 clib_memcpy_fast (ip6srv, &sm->cache_hdr,
1694 sizeof (ip6_header_t));
1696 ip6srv->ip.src_address = src0;
1697 ip6srv->ip.dst_address = seg0;
1699 if (PREDICT_FALSE (gtpu_type) != GTPU_TYPE_GTPU)
1701 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
1703 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
1706 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
1708 ip6srv->sr.segments_left = 0;
1709 ip6srv->sr.last_entry = 0;
1711 ip6srv->sr.length = sizeof (ip6_address_t) / 8;
1712 ip6srv->sr.segments[0] = seg0;
1716 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
1718 if ((clib_net_to_host_u32
1719 (encap->ip_version_traffic_class_and_flow_label)
1721 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
1723 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
1725 ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
1726 if ((clib_net_to_host_u32
1727 (encap->ip_version_traffic_class_and_flow_label)
1730 // Bad encap packet.
1731 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1736 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
1738 ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
1739 if ((clib_net_to_host_u32
1740 (encap->ip_version_traffic_class_and_flow_label)
1743 // Bad encap packet.
1744 next0 = SRV6_END_M_GTP6_D_NEXT_DROP;
1749 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
1751 ip6srv->ip.protocol = IP_PROTOCOL_IP6_ETHERNET;
1756 ip6srv->ip.payload_length =
1757 clib_host_to_net_u16 (len0 + hdr_len - sizeof (ip6_header_t));
1761 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
1762 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1764 srv6_end_rewrite_trace_t *tr =
1765 vlib_add_trace (vm, node, b0, sizeof (*tr));
1766 clib_memcpy (tr->src.as_u8, ip6srv->ip.src_address.as_u8,
1767 sizeof (ip6_address_t));
1768 clib_memcpy (tr->dst.as_u8, ip6srv->ip.dst_address.as_u8,
1769 sizeof (ip6_address_t));
1771 clib_memcpy (tr->sr_prefix.as_u8, ls_param->sr_prefix.as_u8,
1772 sizeof (ip6_address_t));
1773 tr->sr_prefixlen = ls_param->sr_prefixlen;
1778 vlib_increment_combined_counter
1780 SRV6_END_M_GTP6_D_NEXT_DROP) ? &(sm2->sr_ls_invalid_counters) :
1781 &(sm2->sr_ls_valid_counters)), thread_index,
1782 ls0 - sm2->localsids, 1, vlib_buffer_length_in_chain (vm, b0));
1784 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1785 n_left_to_next, bi0, next0);
1788 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1791 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_node_index,
1792 SRV6_END_ERROR_M_GTP6_D_BAD_PACKETS, bad_n);
1794 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_node_index,
1795 SRV6_END_ERROR_M_GTP6_D_PACKETS, good_n);
1797 return frame->n_vectors;
1800 // Function for SRv6 GTP6.D.DI function
1801 VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm,
1802 vlib_node_runtime_t * node,
1803 vlib_frame_t * frame)
1805 srv6_end_main_v6_decap_di_t *sm = &srv6_end_main_v6_decap_di;
1806 ip6_sr_main_t *sm2 = &sr_main;
1807 u32 n_left_from, next_index, *from, *to_next;
1808 u32 thread_index = vm->thread_index;
1809 srv6_end_gtp6_param_t *ls_param;
1811 u32 good_n = 0, bad_n = 0;
1813 from = vlib_frame_vector_args (frame);
1814 n_left_from = frame->n_vectors;
1815 next_index = node->cached_next_index;
1817 while (n_left_from > 0)
1821 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1823 while (n_left_from > 0 && n_left_to_next > 0)
1827 ip6_sr_localsid_t *ls0;
1829 ip6_gtpu_header_t *hdr0 = NULL;
1844 ip6_header_t *encap = NULL;
1845 gtpu_pdu_session_t *sess;
1847 u32 next0 = SRV6_END_M_GTP6_D_DI_NEXT_LOOKUP;
1855 n_left_to_next -= 1;
1857 b0 = vlib_get_buffer (vm, bi0);
1859 pool_elt_at_index (sm2->localsids,
1860 vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1862 ls_param = (srv6_end_gtp6_param_t *) ls0->plugin_mem;
1864 hdr0 = vlib_buffer_get_current (b0);
1866 hdrlen = sizeof (ip6_gtpu_header_t);
1868 len0 = vlib_buffer_length_in_chain (vm, b0);
1870 if ((hdr0->ip6.protocol != IP_PROTOCOL_UDP)
1871 || (hdr0->udp.dst_port !=
1872 clib_host_to_net_u16 (SRV6_GTP_UDP_DST_PORT))
1873 || (len0 < sizeof (ip6_gtpu_header_t)))
1875 next0 = SRV6_END_M_GTP6_D_DI_NEXT_DROP;
1881 dst0 = hdr0->ip6.dst_address;
1882 src0 = hdr0->ip6.src_address;
1884 gtpu_type = hdr0->gtpu.type;
1886 seg0 = ls_param->sr_prefix;
1887 teid = hdr0->gtpu.teid;
1888 teidp = (u8 *) & teid;
1890 seqp = (u8 *) & seq;
1892 if (hdr0->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
1894 // Extention header.
1895 hdrlen += sizeof (gtpu_exthdr_t);
1897 seq = hdr0->gtpu.ext->seq;
1899 if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
1901 // PDU Session Container.
1903 (gtpu_pdu_session_t *) (((char *) hdr0) + hdrlen);
1904 qfi = sess->u.val & ~GTPU_PDU_SESSION_P_BIT_MASK;
1907 hdrlen += sizeof (gtpu_pdu_session_t);
1909 if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
1911 hdrlen += sizeof (gtpu_paging_policy_t);
1916 offset = ls_param->sr_prefixlen / 8;
1917 shift = ls_param->sr_prefixlen % 8;
1920 if (PREDICT_TRUE (shift == 0))
1922 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1923 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1924 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1926 clib_memcpy_fast (&seg0.as_u8[offset], seqp, 2);
1930 clib_memcpy_fast (&seg0.as_u8[offset], teidp, 4);
1936 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
1937 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
1941 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
1944 seg0.as_u8[offset + 4] = qfi;
1951 if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
1952 || gtpu_type == GTPU_TYPE_ECHO_REPLY
1953 || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
1955 for (idx = 0; idx < 2; idx++)
1957 seg0.as_u8[offset + idx] |= seqp[idx] >> shift;
1958 seg0.as_u8[offset + idx + 1] |=
1959 seqp[idx] << (8 - shift);
1964 for (idx = 0; idx < 4; idx++)
1966 seg0.as_u8[offset + idx] |= teidp[idx] >> shift;
1967 seg0.as_u8[offset + idx + 1] |=
1968 teidp[idx] << (8 - shift);
1975 ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
1976 ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
1980 qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
1983 seg0.as_u8[offset + 4] |= qfi >> shift;
1984 seg0.as_u8[offset + 5] |= qfi << (8 - shift);
1988 // jump over variable length data
1989 vlib_buffer_advance (b0, (word) hdrlen);
1991 // get length of encapsulated IPv6 packet (the remaining part)
1992 len0 = vlib_buffer_length_in_chain (vm, b0);
1994 if (PREDICT_TRUE (gtpu_type == GTPU_TYPE_GTPU))
1996 encap = vlib_buffer_get_current (b0);
2000 ip6srv_combo_header_t *ip6srv;
2001 ip6_sr_policy_t *sr_policy = NULL;
2002 ip6_sr_sl_t *sl = NULL;
2007 mhash_get (&sm2->sr_policies_index_hash,
2008 &ls_param->sr_prefix);
2011 sr_policy = pool_elt_at_index (sm2->sr_policies, p[0]);
2016 vec_foreach (sl_index, sr_policy->segments_lists)
2018 sl = pool_elt_at_index (sm2->sid_lists, *sl_index);
2024 hdr_len = sizeof (ip6srv_combo_header_t);
2027 hdr_len += vec_len (sl->segments) * sizeof (ip6_address_t);
2029 hdr_len += sizeof (ip6_address_t) * 2;
2031 // jump back to data[0] or pre_data if required
2032 vlib_buffer_advance (b0, -(word) hdr_len);
2034 ip6srv = vlib_buffer_get_current (b0);
2038 clib_memcpy_fast (ip6srv, sl->rewrite,
2039 vec_len (sl->rewrite));
2041 if (vec_len (sl->segments) > 1)
2043 ip6srv->ip.src_address = src0;
2046 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
2048 ip6srv->sr.segments_left += 2;
2049 ip6srv->sr.last_entry += 2;
2051 ip6srv->sr.length += ((sizeof (ip6_address_t) * 2) / 8);
2053 ip6srv->sr.segments[0] = dst0;
2054 ip6srv->sr.segments[1] = seg0;
2056 clib_memcpy_fast (&ip6srv->sr.segments[2],
2057 (u8 *) (sl->rewrite +
2058 sizeof (ip6_header_t) +
2059 sizeof (ip6_sr_header_t)),
2060 vec_len (sl->segments) *
2061 sizeof (ip6_address_t));
2065 ip6srv->ip.src_address = src0;
2066 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
2068 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
2069 ip6srv->sr.segments_left = 2;
2070 ip6srv->sr.last_entry = 1;
2072 ((sizeof (ip6_sr_header_t) +
2073 2 * sizeof (ip6_address_t)) / 8) - 1;
2074 ip6srv->sr.flags = 0;
2077 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
2079 ip6srv->sr.segments[0] = dst0;
2080 ip6srv->sr.segments[1] = seg0;
2082 if (vec_len (sl->segments))
2084 ip6srv->sr.segments[2] = sl->segments[0];
2085 ip6srv->sr.last_entry++;
2086 ip6srv->sr.length += sizeof (ip6_address_t) / 8;
2092 clib_memcpy_fast (ip6srv, &sm->cache_hdr,
2093 sizeof (ip6_header_t));
2095 ip6srv->ip.src_address = src0;
2096 ip6srv->ip.dst_address = seg0;
2098 ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
2099 ip6srv->sr.segments_left = 1;
2100 ip6srv->sr.last_entry = 0;
2102 ((sizeof (ip6_sr_header_t) +
2103 sizeof (ip6_address_t)) / 8) - 1;
2104 ip6srv->sr.flags = 0;
2107 clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
2109 ip6srv->sr.segments[0] = dst0;
2112 ip6srv->ip.payload_length =
2113 clib_host_to_net_u16 (len0 + hdr_len - sizeof (ip6_header_t));
2114 ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
2116 if (PREDICT_TRUE (encap != NULL))
2118 if (ls_param->nhtype == SRV6_NHTYPE_NONE)
2120 if ((clib_net_to_host_u32
2121 (encap->ip_version_traffic_class_and_flow_label) >>
2123 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
2125 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
2127 else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
2129 ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
2130 if ((clib_net_to_host_u32
2131 (encap->ip_version_traffic_class_and_flow_label) >>
2134 // Bad encap packet.
2135 next0 = SRV6_END_M_GTP6_D_DI_NEXT_DROP;
2140 else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
2142 ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
2143 if ((clib_net_to_host_u32
2144 (encap->ip_version_traffic_class_and_flow_label) >>
2147 // Bad encap packet.
2148 next0 = SRV6_END_M_GTP6_D_DI_NEXT_DROP;
2153 else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
2155 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
2160 ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
2165 if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
2166 PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
2168 srv6_end_rewrite_trace_t *tr =
2169 vlib_add_trace (vm, node, b0, sizeof (*tr));
2170 clib_memcpy (tr->src.as_u8, ip6srv->ip.src_address.as_u8,
2171 sizeof (ip6_address_t));
2172 clib_memcpy (tr->dst.as_u8, ip6srv->ip.dst_address.as_u8,
2173 sizeof (ip6_address_t));
2175 clib_memcpy (tr->sr_prefix.as_u8, ls_param->sr_prefix.as_u8,
2176 sizeof (ip6_address_t));
2177 tr->sr_prefixlen = ls_param->sr_prefixlen;
2182 vlib_increment_combined_counter
2184 SRV6_END_M_GTP6_D_DI_NEXT_DROP) ?
2185 &(sm2->sr_ls_invalid_counters) : &(sm2->sr_ls_valid_counters)),
2186 thread_index, ls0 - sm2->localsids, 1,
2187 vlib_buffer_length_in_chain (vm, b0));
2189 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
2190 n_left_to_next, bi0, next0);
2193 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2196 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_di_node_index,
2197 SRV6_END_ERROR_M_GTP6_D_DI_BAD_PACKETS, bad_n);
2199 vlib_node_increment_counter (vm, sm->end_m_gtp6_d_di_node_index,
2200 SRV6_END_ERROR_M_GTP6_D_DI_PACKETS, good_n);
2202 return frame->n_vectors;
2205 VLIB_REGISTER_NODE (srv6_end_m_gtp6_e) =
2207 .name = "srv6-end-m-gtp6-e",.vector_size = sizeof (u32),.format_trace =
2208 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
2209 ARRAY_LEN (srv6_end_error_v6_e_strings),.error_strings =
2210 srv6_end_error_v6_e_strings,.n_next_nodes =
2211 SRV6_END_M_GTP6_E_N_NEXT,.next_nodes =
2213 [SRV6_END_M_GTP6_E_NEXT_DROP] = "error-drop",
2214 [SRV6_END_M_GTP6_E_NEXT_LOOKUP] = "ip6-lookup",}
2217 VLIB_REGISTER_NODE (srv6_end_m_gtp6_d) =
2219 .name = "srv6-end-m-gtp6-d",.vector_size = sizeof (u32),.format_trace =
2220 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
2221 ARRAY_LEN (srv6_end_error_v6_d_strings),.error_strings =
2222 srv6_end_error_v6_d_strings,.n_next_nodes =
2223 SRV6_END_M_GTP6_D_N_NEXT,.next_nodes =
2225 [SRV6_END_M_GTP6_D_NEXT_DROP] = "error-drop",
2226 [SRV6_END_M_GTP6_D_NEXT_LOOKUP] = "ip6-lookup",}
2229 VLIB_REGISTER_NODE (srv6_end_m_gtp6_d_di) =
2231 .name = "srv6-end-m-gtp6-d-di",.vector_size = sizeof (u32),.format_trace =
2232 format_srv6_end_rewrite_trace6,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
2233 ARRAY_LEN (srv6_end_error_v6_d_di_strings),.error_strings =
2234 srv6_end_error_v6_d_di_strings,.n_next_nodes =
2235 SRV6_END_M_GTP6_D_DI_N_NEXT,.next_nodes =
2237 [SRV6_END_M_GTP6_D_DI_NEXT_DROP] = "error-drop",
2238 [SRV6_END_M_GTP6_D_DI_NEXT_LOOKUP] = "ip6-lookup",}
2242 * fd.io coding-style-patch-verification: ON
2245 * eval: (c-set-style "gnu")