_(M_GTP4_E_PACKETS, "srv6 End.M.GTP4.E packets") \
_(M_GTP4_E_BAD_PACKETS, "srv6 End.M.GTP4.E bad packets")
-#define foreach_srv6_end_v4_d_error \
- _(M_GTP4_D_PACKETS, "srv6 End.M.GTP4.D packets") \
- _(M_GTP4_D_BAD_PACKETS, "srv6 End.M.GTP4.D bad packets")
+#define foreach_srv6_t_v4_d_error \
+ _(M_GTP4_D_PACKETS, "srv6 T.M.GTP4.D packets") \
+ _(M_GTP4_D_BAD_PACKETS, "srv6 T.M.GTP4.D bad packets")
#define foreach_srv6_end_v6_e_error \
_(M_GTP6_E_PACKETS, "srv6 End.M.GTP6.E packets") \
typedef enum
{
-#define _(sym,str) SRV6_END_ERROR_##sym,
- foreach_srv6_end_v4_d_error
+#define _(sym,str) SRV6_T_ERROR_##sym,
+ foreach_srv6_t_v4_d_error
#undef _
- SRV6_END_N_V4_D_ERROR,
-} srv6_end_error_v4_d_t;
+ SRV6_T_N_V4_D_ERROR,
+} srv6_t_error_v4_d_t;
typedef enum
{
#undef _
};
+static char *srv6_t_error_v4_d_strings[] = {
+#define _(sym,string) string,
+ foreach_srv6_t_v4_d_error
+#undef _
+};
+
static char *srv6_end_error_v6_e_strings[] = {
#define _(sym,string) string,
foreach_srv6_end_v6_e_error
SRV6_END_M_GTP4_E_N_NEXT,
} srv6_end_m_gtp4_e_next_t;
+typedef enum
+{
+ SRV6_T_M_GTP4_D_NEXT_DROP,
+ SRV6_T_M_GTP4_D_NEXT_LOOKUP,
+ SRV6_T_M_GTP4_D_N_NEXT,
+} srv6_T_m_gtp4_d_next_t;
+
typedef enum
{
SRV6_END_M_GTP6_E_NEXT_DROP,
#endif
}
-static inline void
-gtp_type_set (gtpu_header_t * gtpu, u16 tag)
+static inline u8
+gtpu_type_get (u16 tag)
{
u16 val;
val = clib_net_to_host_u16 (tag);
if (val & SRH_TAG_ECHO_REPLY)
- gtpu->type = GTPU_TYPE_ECHO_REPLY;
+ return GTPU_TYPE_ECHO_REPLY;
else if (val & SRH_TAG_ECHO_REQUEST)
- gtpu->type = GTPU_TYPE_ECHO_REQUEST;
+ return GTPU_TYPE_ECHO_REQUEST;
else if (val & SRH_TAG_ERROR_INDICATION)
- gtpu->type = GTPU_TYPE_ERROR_INDICATION;
+ return GTPU_TYPE_ERROR_INDICATION;
else if (val & SRH_TAG_END_MARKER)
- gtpu->type = GTPU_TYPE_END_MARKER;
+ return GTPU_TYPE_END_MARKER;
+
+ return GTPU_TYPE_GTPU;
}
// Function for SRv6 GTP4.E function.
}
else
{
+ u8 gtpu_type = 0;
u16 tag = 0;
- u32 teid;
+ u32 teid = 0;
u8 *teid8p = (u8 *) & teid;
u8 qfi = 0;
+ u16 seq = 0;
u32 index;
u32 offset, shift;
u32 hdrlen = 0;
len0 = vlib_buffer_length_in_chain (vm, b0);
- offset = ls0->localsid_len / 8;
- shift = ls0->localsid_len % 8;
+ offset = ls0->localsid_prefix_len / 8;
+ shift = ls0->localsid_prefix_len % 8;
+
+ gtpu_type = gtpu_type_get (tag);
if (PREDICT_TRUE (shift == 0))
{
qfi = dst0.as_u8[offset + 4];
- clib_memcpy_fast (teid8p, &dst0.as_u8[offset + 5], 4);
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ clib_memcpy_fast (&seq, &dst0.as_u8[offset + 5], 2);
+ }
+ else
+ {
+ clib_memcpy_fast (teid8p, &dst0.as_u8[offset + 5], 4);
+ }
}
else
{
+ u8 *sp;
+
for (index = 0; index < 4; index++)
{
dst4.as_u8[index] = dst0.as_u8[offset + index] << shift;
qfi |= dst0.as_u8[offset + 4] << shift;
qfi |= dst0.as_u8[offset + 5] >> (8 - shift);
- for (index = 0; index < 4; index++)
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ sp = (u8 *) & seq;
+ for (index = 0; index < 2; index++)
+ {
+ sp[index] = dst0.as_u8[offset + 5 + index] << shift;
+ sp[index] |=
+ dst0.as_u8[offset + 6 + index] >> (8 - shift);
+ }
+ }
+ else
{
- *teid8p = dst0.as_u8[offset + 5 + index] << shift;
- *teid8p |=
- dst0.as_u8[offset + 6 + index] >> (8 - shift);
- teid8p++;
+ for (index = 0; index < 4; index++)
+ {
+ *teid8p = dst0.as_u8[offset + 5 + index] << shift;
+ *teid8p |=
+ dst0.as_u8[offset + 6 + index] >> (8 - shift);
+ teid8p++;
+ }
}
}
{
hdrlen =
sizeof (gtpu_exthdr_t) + sizeof (gtpu_pdu_session_t);
- len0 += hdrlen;
}
+ else if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ hdrlen = sizeof (gtpu_exthdr_t);
+ }
+ len0 += hdrlen;
+
hdrlen += sizeof (ip4_gtpu_header_t);
// IPv4 GTP-U header creation.
hdr0->gtpu.teid = teid;
hdr0->gtpu.length = clib_host_to_net_u16 (len0);
- if (PREDICT_FALSE (tag != 0))
- {
- gtp_type_set (&hdr0->gtpu, tag);
- }
+ hdr0->gtpu.type = gtpu_type;
if (qfi)
{
gtpu_pdu_session_t *sess;
hdr0->gtpu.ver_flags |= GTPU_EXTHDR_FLAG;
+
hdr0->gtpu.ext->seq = 0;
+
hdr0->gtpu.ext->npdu_num = 0;
hdr0->gtpu.ext->nextexthdr = GTPU_EXTHDR_PDU_SESSION;
sess->nextexthdr = 0;
}
+ if (gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ hdr0->gtpu.ver_flags |= GTPU_SEQ_FLAG;
+ hdr0->gtpu.ext->seq = seq;
+ hdr0->gtpu.ext->npdu_num = 0;
+ hdr0->gtpu.ext->nextexthdr = 0;
+ }
+
offset = ls_param->v4src_position / 8;
shift = ls_param->v4src_position % 8;
return frame->n_vectors;
}
+// Function for SRv6 GTP4.D function.
+VLIB_NODE_FN (srv6_t_m_gtp4_d) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
+{
+ srv6_t_main_v4_decap_t *sm = &srv6_t_main_v4_decap;
+ ip6_sr_main_t *sm2 = &sr_main;
+ u32 n_left_from, next_index, *from, *to_next;
+
+ u32 good_n = 0, bad_n = 0;
+
+ from = vlib_frame_vector_args (frame);
+ n_left_from = frame->n_vectors;
+ next_index = node->cached_next_index;
+
+ while (n_left_from > 0)
+ {
+ u32 n_left_to_next;
+
+ vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
+
+ while (n_left_from > 0 && n_left_to_next > 0)
+ {
+ u32 bi0;
+ vlib_buffer_t *b0;
+ ip6_sr_sl_t *sl0;
+ srv6_end_gtp4_param_t *ls_param;
+ ip4_header_t *ip4;
+
+ uword len0;
+
+ u32 next0 = SRV6_T_M_GTP4_D_NEXT_LOOKUP;
+
+ // defaults
+ bi0 = from[0];
+ to_next[0] = bi0;
+ from += 1;
+ to_next += 1;
+ n_left_from -= 1;
+ n_left_to_next -= 1;
+
+ b0 = vlib_get_buffer (vm, bi0);
+
+ sl0 =
+ pool_elt_at_index (sm2->sid_lists,
+ vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
+
+ ls_param = (srv6_end_gtp4_param_t *) sl0->plugin_mem;
+
+ len0 = vlib_buffer_length_in_chain (vm, b0);
+
+ ip4 = vlib_buffer_get_current (b0);
+
+ if (ip4->protocol != IP_PROTOCOL_UDP
+ || len0 < sizeof (ip4_gtpu_header_t))
+ {
+ next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
+
+ bad_n++;
+ }
+ else
+ {
+ uword *p;
+ ip6_sr_policy_t *sr_policy = NULL;
+ ip6_sr_sl_t *sl = NULL;
+ u32 *sl_index;
+ u32 hdr_len;
+
+ ip4_gtpu_header_t *hdr;
+ ip4_address_t src, dst;
+ u8 *srcp, *dstp;
+ ip6_header_t *encap = NULL;
+ ip6_address_t seg;
+ ip6_address_t src6;
+ u8 gtpu_type;
+ u32 teid;
+ u8 *teidp;
+ u8 qfi = 0;
+ u8 *qfip = NULL;
+ u16 seq = 0;
+ u8 *seqp;
+ u32 offset, shift, index;
+ ip6srv_combo_header_t *ip6srv;
+ gtpu_pdu_session_t *sess = NULL;
+
+ // Decap from GTP-U.
+ hdr = (ip4_gtpu_header_t *) ip4;
+
+ hdr_len = sizeof (ip4_gtpu_header_t);
+
+ teid = hdr->gtpu.teid;
+ teidp = (u8 *) & teid;
+
+ seqp = (u8 *) & seq;
+
+ gtpu_type = hdr->gtpu.type;
+
+ if (hdr->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
+ {
+ // Extention header.
+ hdr_len += sizeof (gtpu_exthdr_t);
+
+ seq = hdr->gtpu.ext->seq;
+
+ if (hdr->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
+ {
+ // PDU Session Container.
+ sess =
+ (gtpu_pdu_session_t *) (((char *) hdr) + hdr_len);
+ qfi = sess->u.val & ~GTPU_PDU_SESSION_P_BIT_MASK;
+ qfip = (u8 *) & qfi;
+
+ hdr_len += sizeof (gtpu_pdu_session_t);
+
+ if (sess->u.val & GTPU_PDU_SESSION_P_BIT_MASK)
+ {
+ hdr_len += sizeof (gtpu_paging_policy_t);
+ }
+ }
+ }
+
+ src = hdr->ip4.src_address;
+ srcp = (u8 *) & src;
+
+ dst = hdr->ip4.dst_address;
+ dstp = (u8 *) & dst;
+
+ seg = ls_param->sr_prefix;
+
+ offset = ls_param->sr_prefixlen / 8;
+ shift = ls_param->sr_prefixlen % 8;
+
+ if (PREDICT_TRUE (shift == 0))
+ {
+ clib_memcpy_fast (&seg.as_u8[offset], dstp, 4);
+
+ if (qfip)
+ {
+ qfi =
+ ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
+ ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
+
+ if (sess->type)
+ {
+ qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
+ }
+
+ seg.as_u8[offset + 4] = qfi;
+ }
+
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ clib_memcpy_fast (&seg.as_u8[offset + 5], seqp, 2);
+ }
+ else
+ {
+ clib_memcpy_fast (&seg.as_u8[offset + 5], teidp, 4);
+ }
+ }
+ else
+ {
+ for (index = 0; index < 4; index++)
+ {
+ seg.as_u8[offset + index] |= dstp[index] >> shift;
+ seg.as_u8[offset + index + 1] |=
+ dstp[index] << (8 - shift);
+ }
+
+ if (qfip)
+ {
+ qfi =
+ ((qfi & GTPU_PDU_SESSION_QFI_MASK) << 2) |
+ ((qfi & GTPU_PDU_SESSION_R_BIT_MASK) >> 5);
+
+ if (sess->type)
+ {
+ qfi |= SRV6_PDU_SESSION_U_BIT_MASK;
+ }
+
+ seg.as_u8[offset + 4] |= qfi >> shift;
+ seg.as_u8[offset + 5] |= qfi << (8 - shift);
+ }
+
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ for (index = 0; index < 2; index++)
+ {
+ seg.as_u8[offset + 5 + index] |=
+ seqp[index] >> shift;
+ seg.as_u8[offset + 6 + index] |=
+ seqp[index] << (8 - shift);
+ }
+ }
+ else
+ {
+ for (index = 0; index < 4; index++)
+ {
+ seg.as_u8[offset + index + 5] |=
+ teidp[index] >> shift;
+ seg.as_u8[offset + index + 6] |=
+ teidp[index] << (8 - shift);
+ }
+ }
+ }
+
+ src6 = ls_param->v6src_prefix;
+
+ offset = ls_param->v6src_prefixlen / 8;
+ shift = ls_param->v6src_prefixlen % 8;
+
+ if (PREDICT_TRUE (shift == 0))
+ {
+ clib_memcpy_fast (&src6.as_u8[offset], srcp, 4);
+ }
+ else
+ {
+ for (index = 0; index < 4; index++)
+ {
+ src6.as_u8[offset + index] |= srcp[offset] >> shift;
+ src6.as_u8[offset + index + 1] |=
+ srcp[offset] << (8 - shift);
+ }
+ }
+
+ vlib_buffer_advance (b0, (word) hdr_len);
+
+ // Encap to SRv6.
+ if (PREDICT_TRUE (gtpu_type == GTPU_TYPE_GTPU))
+ {
+ encap = vlib_buffer_get_current (b0);
+ }
+
+ len0 = vlib_buffer_length_in_chain (vm, b0);
+
+ p =
+ mhash_get (&sm2->sr_policies_index_hash,
+ &ls_param->sr_prefix);
+ if (p)
+ {
+ sr_policy = pool_elt_at_index (sm2->sr_policies, p[0]);
+ }
+
+ if (sr_policy)
+ {
+ vec_foreach (sl_index, sr_policy->segments_lists)
+ {
+ sl = pool_elt_at_index (sm2->sid_lists, *sl_index);
+ if (sl != NULL)
+ break;
+ }
+ }
+
+ if (sl)
+ {
+ hdr_len = sizeof (ip6srv_combo_header_t);
+ hdr_len += vec_len (sl->segments) * sizeof (ip6_address_t);
+ hdr_len += sizeof (ip6_address_t);
+ }
+ else
+ {
+ hdr_len = sizeof (ip6_header_t);
+
+ if (PREDICT_FALSE (gtpu_type != GTPU_TYPE_GTPU))
+ {
+ hdr_len += sizeof (ip6_sr_header_t);
+ hdr_len += sizeof (ip6_address_t);
+ }
+ }
+
+ vlib_buffer_advance (b0, -(word) hdr_len);
+ ip6srv = vlib_buffer_get_current (b0);
+
+ if (sl)
+ {
+ clib_memcpy_fast (ip6srv, sl->rewrite,
+ vec_len (sl->rewrite));
+
+ if (vec_len (sl->segments) > 1)
+ {
+ ip6srv->sr.tag =
+ clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+
+ ip6srv->sr.segments_left += 1;
+ ip6srv->sr.last_entry += 1;
+
+ ip6srv->sr.length += sizeof (ip6_address_t) / 8;
+ ip6srv->sr.segments[0] = seg;
+
+ clib_memcpy_fast (&ip6srv->sr.segments[1],
+ (u8 *) (sl->rewrite +
+ sizeof (ip6_header_t) +
+ sizeof (ip6_sr_header_t)),
+ vec_len (sl->segments) *
+ sizeof (ip6_address_t));
+ }
+ else
+ {
+ ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
+
+ ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
+
+ ip6srv->sr.segments_left = 1;
+ ip6srv->sr.last_entry = 0;
+
+ ip6srv->sr.length =
+ ((sizeof (ip6_sr_header_t) +
+ sizeof (ip6_address_t)) / 8) - 1;
+ ip6srv->sr.flags = 0;
+
+ ip6srv->sr.tag =
+ clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+
+ ip6srv->sr.segments[0] = seg;
+ if (vec_len (sl->segments))
+ {
+ ip6srv->sr.segments[1] = sl->segments[0];
+ ip6srv->sr.length += sizeof (ip6_address_t) / 8;
+ ip6srv->sr.last_entry++;
+ }
+ }
+
+ if (PREDICT_TRUE (encap != NULL))
+ {
+ if (ls_param->nhtype == SRV6_NHTYPE_NONE)
+ {
+ if ((clib_net_to_host_u32
+ (encap->ip_version_traffic_class_and_flow_label)
+ >> 28) == 6)
+ ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
+ else
+ ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
+ }
+ else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
+ {
+ ip6srv->sr.protocol = IP_PROTOCOL_IP_IN_IP;
+ if ((clib_net_to_host_u32
+ (encap->ip_version_traffic_class_and_flow_label)
+ >> 28) != 4)
+ {
+ // Bad encap packet.
+ next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
+ bad_n++;
+ goto DONE;
+ }
+ }
+ else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
+ {
+ ip6srv->sr.protocol = IP_PROTOCOL_IPV6;
+ if ((clib_net_to_host_u32
+ (encap->ip_version_traffic_class_and_flow_label)
+ >> 28) != 6)
+ {
+ // Bad encap packet.
+ next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
+ bad_n++;
+ goto DONE;
+ }
+ }
+ else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
+ {
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
+ }
+ }
+ else
+ {
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
+ }
+ }
+ else
+ {
+ clib_memcpy_fast (ip6srv, &sm->cache_hdr,
+ sizeof (ip6_header_t));
+
+ ip6srv->ip.dst_address = seg;
+
+ if (PREDICT_FALSE (gtpu_type != GTPU_TYPE_GTPU))
+ {
+ ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
+
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
+
+ ip6srv->sr.tag =
+ clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+
+ ip6srv->sr.segments_left = 0;
+ ip6srv->sr.last_entry = 0;
+
+ ip6srv->sr.length = sizeof (ip6_address_t) / 8;
+ ip6srv->sr.segments[0] = seg;
+ }
+ else
+ {
+ if (ls_param->nhtype == SRV6_NHTYPE_NONE)
+ {
+ if ((clib_net_to_host_u32
+ (encap->ip_version_traffic_class_and_flow_label)
+ >> 28) == 6)
+ ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
+ else
+ ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
+ }
+ else if (ls_param->nhtype == SRV6_NHTYPE_IPV4)
+ {
+ ip6srv->ip.protocol = IP_PROTOCOL_IP_IN_IP;
+ if ((clib_net_to_host_u32
+ (encap->ip_version_traffic_class_and_flow_label)
+ >> 28) != 4)
+ {
+ // Bad encap packet.
+ next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
+ bad_n++;
+ goto DONE;
+ }
+ }
+ else if (ls_param->nhtype == SRV6_NHTYPE_IPV6)
+ {
+ ip6srv->ip.protocol = IP_PROTOCOL_IPV6;
+ if ((clib_net_to_host_u32
+ (encap->ip_version_traffic_class_and_flow_label)
+ >> 28) != 6)
+ {
+ // Bad encap packet.
+ next0 = SRV6_T_M_GTP4_D_NEXT_DROP;
+ bad_n++;
+ goto DONE;
+ }
+ }
+ else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
+ {
+ ip6srv->ip.protocol = IP_PROTOCOL_IP6_ETHERNET;
+ }
+ }
+ }
+
+ ip6srv->ip.src_address = src6;
+
+ ip6srv->ip.payload_length =
+ clib_host_to_net_u16 (len0 + hdr_len - sizeof (ip6_header_t));
+
+ good_n++;
+
+ if (PREDICT_FALSE (node->flags & VLIB_NODE_FLAG_TRACE) &&
+ PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
+ {
+ srv6_end_rewrite_trace_t *tr =
+ vlib_add_trace (vm, node, b0, sizeof (*tr));
+ clib_memcpy (tr->src.as_u8, ip6srv->ip.src_address.as_u8,
+ sizeof (tr->src.as_u8));
+ clib_memcpy (tr->dst.as_u8, ip6srv->ip.dst_address.as_u8,
+ sizeof (tr->dst.as_u8));
+ }
+ }
+
+ DONE:
+ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+ n_left_to_next, bi0, next0);
+ }
+
+ vlib_put_next_frame (vm, node, next_index, n_left_to_next);
+ }
+
+ vlib_node_increment_counter (vm, sm->t_m_gtp4_d_node_index,
+ SRV6_T_ERROR_M_GTP4_D_BAD_PACKETS, bad_n);
+
+ vlib_node_increment_counter (vm, sm->t_m_gtp4_d_node_index,
+ SRV6_T_ERROR_M_GTP4_D_PACKETS, good_n);
+
+ return frame->n_vectors;
+}
+
VLIB_REGISTER_NODE (srv6_end_m_gtp4_e) =
{
.name = "srv6-end-m-gtp4-e",.vector_size = sizeof (u32),.format_trace =
srv6_end_error_v4_strings,.n_next_nodes =
SRV6_END_M_GTP4_E_N_NEXT,.next_nodes =
{
- [SRV6_END_M_GTP4_E_NEXT_DROP] =
- "error-drop",[SRV6_END_M_GTP4_E_NEXT_LOOKUP] = "ip4-lookup",}
+ [SRV6_END_M_GTP4_E_NEXT_DROP] = "error-drop",
+ [SRV6_END_M_GTP4_E_NEXT_LOOKUP] = "ip4-lookup",}
+,};
+
+VLIB_REGISTER_NODE (srv6_t_m_gtp4_d) =
+{
+ .name = "srv6-t-m-gtp4-d",.vector_size = sizeof (u32),.format_trace =
+ format_srv6_end_rewrite_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
+ ARRAY_LEN (srv6_t_error_v4_d_strings),.error_strings =
+ srv6_t_error_v4_d_strings,.n_next_nodes =
+ SRV6_T_M_GTP4_D_N_NEXT,.next_nodes =
+ {
+ [SRV6_T_M_GTP4_D_NEXT_DROP] = "error-drop",
+ [SRV6_T_M_GTP4_D_NEXT_LOOKUP] = "ip6-lookup",}
,};
// Function for SRv6 GTP6.E function
len0 = vlib_buffer_length_in_chain (vm, b0);
- u32 teid;
+ u32 teid = 0;
u8 *teid8p = (u8 *) & teid;
u8 qfi = 0;
+ u16 seq = 0;
+ u8 gtpu_type = 0;
u16 index;
u16 offset, shift;
u32 hdrlen = 0;
- index = ls0->localsid_len;
+ index = ls0->localsid_prefix_len;
index += 8;
offset = index / 8;
shift = index % 8;
+ gtpu_type = gtpu_type_get (tag);
+
if (PREDICT_TRUE (shift == 0))
{
- clib_memcpy_fast (teid8p, &dst0.as_u8[offset], 4);
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ clib_memcpy_fast (&seq, &dst0.as_u8[offset], 2);
+ }
+ else
+ {
+ clib_memcpy_fast (teid8p, &dst0.as_u8[offset], 4);
+ }
qfi = dst0.as_u8[offset + 4];
}
else
{
- for (index = offset; index < offset + 4; index++)
+ u8 *sp;
+
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
{
- *teid8p = dst0.as_u8[index] << shift;
- *teid8p |= dst0.as_u8[index + 1] >> (8 - shift);
- teid8p++;
+ sp = (u8 *) & seq;
+ for (index = 0; index < 2; index++)
+ {
+ sp[index] = dst0.as_u8[offset + index] << shift;
+ sp[index] |=
+ dst0.as_u8[offset + index + 1] >> (8 - shift);
+ }
+ }
+ else
+ {
+ for (index = 0; index < 4; index++)
+ {
+ *teid8p = dst0.as_u8[offset + index] << shift;
+ *teid8p |=
+ dst0.as_u8[offset + index + 1] >> (8 - shift);
+ teid8p++;
+ }
}
qfi |= dst0.as_u8[offset + 4] << shift;
{
hdrlen =
sizeof (gtpu_exthdr_t) + sizeof (gtpu_pdu_session_t);
- len0 += hdrlen;
}
+ else if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ hdrlen = sizeof (gtpu_exthdr_t);
+ }
+
+ len0 += hdrlen;
hdrlen += sizeof (ip6_gtpu_header_t);
vlib_buffer_advance (b0, -(word) hdrlen);
hdr0->gtpu.teid = teid;
hdr0->gtpu.length = clib_host_to_net_u16 (len0);
- if (PREDICT_FALSE (tag != 0))
- {
- gtp_type_set (&hdr0->gtpu, tag);
- }
+ hdr0->gtpu.type = gtpu_type;
if (qfi)
{
gtpu_pdu_session_t *sess;
hdr0->gtpu.ver_flags |= GTPU_EXTHDR_FLAG;
+
hdr0->gtpu.ext->seq = 0;
hdr0->gtpu.ext->npdu_num = 0;
hdr0->gtpu.ext->nextexthdr = GTPU_EXTHDR_PDU_SESSION;
sess->nextexthdr = 0;
}
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ hdr0->gtpu.ver_flags |= GTPU_SEQ_FLAG;
+ hdr0->gtpu.ext->seq = seq;
+ hdr0->gtpu.ext->npdu_num = 0;
+ hdr0->gtpu.ext->nextexthdr = 0;
+ }
+
hdr0->udp.length = clib_host_to_net_u16 (len0 +
sizeof (udp_header_t) +
sizeof
u8 gtpu_type = 0;
u8 qfi;
u8 *qfip = NULL;
+ u16 seq = 0;
+ u8 *seqp;
u32 offset, shift;
u32 hdrlen;
ip6_header_t *encap = NULL;
teid = hdr0->gtpu.teid;
teidp = (u8 *) & teid;
- if (hdr0->gtpu.ver_flags & GTPU_EXTHDR_FLAG)
+ seqp = (u8 *) & seq;
+
+ if (hdr0->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
{
// Extention header.
hdrlen += sizeof (gtpu_exthdr_t);
+
+ seq = hdr0->gtpu.ext->seq;
+
if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
{
// PDU Session Container.
offset += 1;
if (PREDICT_TRUE (shift == 0))
{
- clib_memcpy_fast (&seg0.as_u8[offset], teidp, 4);
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ clib_memcpy_fast (&seg0.as_u8[offset], seqp, 2);
+ }
+ else
+ {
+ clib_memcpy_fast (&seg0.as_u8[offset], teidp, 4);
+ }
+
if (qfip)
{
qfi =
{
int idx;
- for (idx = 0; idx < 4; idx++)
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
{
- seg0.as_u8[offset + idx] |= teidp[idx] >> shift;
- seg0.as_u8[offset + idx + 1] |=
- teidp[idx] << (8 - shift);
+ for (idx = 0; idx < 2; idx++)
+ {
+ seg0.as_u8[offset + idx] |= seqp[idx] >> shift;
+ seg0.as_u8[offset + idx + 1] |=
+ seqp[idx] << (8 - shift);
+ }
+ }
+ else
+ {
+ for (idx = 0; idx < 4; idx++)
+ {
+ seg0.as_u8[offset + idx] |= teidp[idx] >> shift;
+ seg0.as_u8[offset + idx + 1] |=
+ teidp[idx] << (8 - shift);
+ }
}
if (qfip)
clib_memcpy_fast (ip6srv, sl->rewrite,
vec_len (sl->rewrite));
- ip6srv->ip.src_address = src0;
- ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
+ if (vec_len (sl->segments) > 1)
+ {
+ ip6srv->ip.src_address = src0;
- ip6srv->sr.tag =
- clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+ ip6srv->sr.tag =
+ clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
- ip6srv->sr.segments_left += 1;
- ip6srv->sr.last_entry += 1;
+ ip6srv->sr.segments_left += 1;
+ ip6srv->sr.last_entry += 1;
- ip6srv->sr.length += sizeof (ip6_address_t) / 8;
- ip6srv->sr.segments[0] = seg0;
+ ip6srv->sr.length += sizeof (ip6_address_t) / 8;
+ ip6srv->sr.segments[0] = seg0;
+
+ clib_memcpy_fast (&ip6srv->sr.segments[1],
+ (u8 *) (sl->rewrite +
+ sizeof (ip6_header_t) +
+ sizeof (ip6_sr_header_t)),
+ vec_len (sl->segments) *
+ sizeof (ip6_address_t));
+ }
+ else
+ {
+ ip6srv->ip.src_address = src0;
+ ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
+
+ ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
+ ip6srv->sr.segments_left = 1;
+ ip6srv->sr.last_entry = 0;
+ ip6srv->sr.length =
+ ((sizeof (ip6_sr_header_t) +
+ sizeof (ip6_address_t)) / 8) - 1;
+ ip6srv->sr.flags = 0;
+
+ ip6srv->sr.tag =
+ clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+
+ ip6srv->sr.segments[0] = seg0;
+
+ if (vec_len (sl->segments))
+ {
+ ip6srv->sr.segments[1] = sl->segments[0];
+ ip6srv->sr.last_entry++;
+ ip6srv->sr.length += sizeof (ip6_address_t) / 8;
+ }
+ }
if (PREDICT_TRUE (encap != NULL))
{
}
else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
{
- ip6srv->sr.protocol = IP_PROTOCOL_NONE;
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
}
}
else
{
- ip6srv->sr.protocol = IP_PROTOCOL_NONE;
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
}
-
- clib_memcpy_fast (&ip6srv->sr.segments[1],
- (u8 *) (sl->rewrite +
- sizeof (ip6_header_t) +
- sizeof (ip6_sr_header_t)),
- vec_len (sl->segments) *
- sizeof (ip6_address_t));
}
else
{
{
ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
- ip6srv->sr.protocol = IP_PROTOCOL_NONE;
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
ip6srv->sr.tag =
clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
}
else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
{
- ip6srv->ip.protocol = IP_PROTOCOL_NONE;
+ ip6srv->ip.protocol = IP_PROTOCOL_IP6_ETHERNET;
}
}
}
u8 gtpu_type = 0;
u8 qfi = 0;
u8 *qfip = NULL;
+ u16 seq = 0;
+ u8 *seqp;
u32 offset, shift;
u32 hdrlen;
ip6_header_t *encap = NULL;
teid = hdr0->gtpu.teid;
teidp = (u8 *) & teid;
- if (hdr0->gtpu.ver_flags & GTPU_EXTHDR_FLAG)
+ seqp = (u8 *) & seq;
+
+ if (hdr0->gtpu.ver_flags & (GTPU_EXTHDR_FLAG | GTPU_SEQ_FLAG))
{
// Extention header.
hdrlen += sizeof (gtpu_exthdr_t);
+
+ seq = hdr0->gtpu.ext->seq;
+
if (hdr0->gtpu.ext->nextexthdr == GTPU_EXTHDR_PDU_SESSION)
{
// PDU Session Container.
offset += 1;
if (PREDICT_TRUE (shift == 0))
{
- clib_memcpy_fast (&seg0.as_u8[offset], teidp, 4);
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
+ {
+ clib_memcpy_fast (&seg0.as_u8[offset], seqp, 2);
+ }
+ else
+ {
+ clib_memcpy_fast (&seg0.as_u8[offset], teidp, 4);
+ }
if (qfip)
{
{
int idx;
- for (idx = 0; idx < 4; idx++)
+ if (gtpu_type == GTPU_TYPE_ECHO_REQUEST
+ || gtpu_type == GTPU_TYPE_ECHO_REPLY
+ || gtpu_type == GTPU_TYPE_ERROR_INDICATION)
{
- seg0.as_u8[offset + idx] |= teidp[idx] >> shift;
- seg0.as_u8[offset + idx + 1] |=
- teidp[idx] << (8 - shift);
+ for (idx = 0; idx < 2; idx++)
+ {
+ seg0.as_u8[offset + idx] |= seqp[idx] >> shift;
+ seg0.as_u8[offset + idx + 1] |=
+ seqp[idx] << (8 - shift);
+ }
+ }
+ else
+ {
+ for (idx = 0; idx < 4; idx++)
+ {
+ seg0.as_u8[offset + idx] |= teidp[idx] >> shift;
+ seg0.as_u8[offset + idx + 1] |=
+ teidp[idx] << (8 - shift);
+ }
}
if (qfip)
clib_memcpy_fast (ip6srv, sl->rewrite,
vec_len (sl->rewrite));
- ip6srv->ip.src_address = src0;
+ if (vec_len (sl->segments) > 1)
+ {
+ ip6srv->ip.src_address = src0;
- ip6srv->sr.tag =
- clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+ ip6srv->sr.tag =
+ clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+
+ ip6srv->sr.segments_left += 2;
+ ip6srv->sr.last_entry += 2;
+
+ ip6srv->sr.length += ((sizeof (ip6_address_t) * 2) / 8);
+
+ ip6srv->sr.segments[0] = dst0;
+ ip6srv->sr.segments[1] = seg0;
+
+ clib_memcpy_fast (&ip6srv->sr.segments[2],
+ (u8 *) (sl->rewrite +
+ sizeof (ip6_header_t) +
+ sizeof (ip6_sr_header_t)),
+ vec_len (sl->segments) *
+ sizeof (ip6_address_t));
+ }
+ else
+ {
+ ip6srv->ip.src_address = src0;
+ ip6srv->ip.protocol = IP_PROTOCOL_IPV6_ROUTE;
+
+ ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
+ ip6srv->sr.segments_left = 2;
+ ip6srv->sr.last_entry = 1;
+ ip6srv->sr.length =
+ ((sizeof (ip6_sr_header_t) +
+ 2 * sizeof (ip6_address_t)) / 8) - 1;
+ ip6srv->sr.flags = 0;
- ip6srv->sr.segments_left += 2;
- ip6srv->sr.last_entry += 2;
+ ip6srv->sr.tag =
+ clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
+
+ ip6srv->sr.segments[0] = dst0;
+ ip6srv->sr.segments[1] = seg0;
+
+ if (vec_len (sl->segments))
+ {
+ ip6srv->sr.segments[2] = sl->segments[0];
+ ip6srv->sr.last_entry++;
+ ip6srv->sr.length += sizeof (ip6_address_t) / 8;
+ }
+ }
}
else
{
ip6srv->ip.src_address = src0;
ip6srv->ip.dst_address = seg0;
+ ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
+ ip6srv->sr.segments_left = 1;
+ ip6srv->sr.last_entry = 0;
+ ip6srv->sr.length =
+ ((sizeof (ip6_sr_header_t) +
+ sizeof (ip6_address_t)) / 8) - 1;
+ ip6srv->sr.flags = 0;
+
ip6srv->sr.tag =
clib_host_to_net_u16 (srh_tagfield[gtpu_type]);
- ip6srv->sr.segments_left += 1;
- ip6srv->sr.last_entry += 1;
- ip6srv->sr.type = ROUTING_HEADER_TYPE_SR;
+ ip6srv->sr.segments[0] = dst0;
}
ip6srv->ip.payload_length =
}
else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP)
{
- ip6srv->sr.protocol = IP_PROTOCOL_NONE;
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
}
}
else
{
- ip6srv->sr.protocol = IP_PROTOCOL_NONE;
- }
-
- ip6srv->sr.length += ((sizeof (ip6_address_t) * 2) / 8);
- ip6srv->sr.segments[0] = dst0;
- ip6srv->sr.segments[1] = seg0;
-
- if (sl)
- {
- clib_memcpy_fast (&ip6srv->sr.segments[2],
- (u8 *) (sl->rewrite +
- sizeof (ip6_header_t) +
- sizeof (ip6_sr_header_t)),
- vec_len (sl->segments) *
- sizeof (ip6_address_t));
+ ip6srv->sr.protocol = IP_PROTOCOL_IP6_ETHERNET;
}
good_n++;
srv6_end_error_v6_e_strings,.n_next_nodes =
SRV6_END_M_GTP6_E_N_NEXT,.next_nodes =
{
- [SRV6_END_M_GTP6_E_NEXT_DROP] =
- "error-drop",[SRV6_END_M_GTP6_E_NEXT_LOOKUP] = "ip6-lookup",}
+ [SRV6_END_M_GTP6_E_NEXT_DROP] = "error-drop",
+ [SRV6_END_M_GTP6_E_NEXT_LOOKUP] = "ip6-lookup",}
,};
VLIB_REGISTER_NODE (srv6_end_m_gtp6_d) =
srv6_end_error_v6_d_strings,.n_next_nodes =
SRV6_END_M_GTP6_D_N_NEXT,.next_nodes =
{
- [SRV6_END_M_GTP6_D_NEXT_DROP] =
- "error-drop",[SRV6_END_M_GTP6_D_NEXT_LOOKUP] = "ip6-lookup",}
+ [SRV6_END_M_GTP6_D_NEXT_DROP] = "error-drop",
+ [SRV6_END_M_GTP6_D_NEXT_LOOKUP] = "ip6-lookup",}
,};
VLIB_REGISTER_NODE (srv6_end_m_gtp6_d_di) =
Code Review / vpp.git / blobdiff