X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fplugins%2Fsrv6-mobile%2Fnode.c;h=6eafefd3f5b2c31d27cb01f36373bba680dd6ff1;hb=79bfd2725;hp=0c2c04e612eff8f77ef2f1e9f10f16baae67302a;hpb=1b81e6ef66cbce15ba1b05904732f92251d531cd;p=vpp.git diff --git a/src/plugins/srv6-mobile/node.c b/src/plugins/srv6-mobile/node.c index 0c2c04e612e..6eafefd3f5b 100644 --- a/src/plugins/srv6-mobile/node.c +++ b/src/plugins/srv6-mobile/node.c @@ -113,9 +113,9 @@ format_srv6_end_rewrite_trace6 (u8 * s, va_list * args) _(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") \ @@ -139,11 +139,11 @@ typedef enum 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 { @@ -175,6 +175,12 @@ static char *srv6_end_error_v4_strings[] = { #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 @@ -200,6 +206,13 @@ typedef enum 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, @@ -233,20 +246,22 @@ hash_uword_to_u16 (uword * key) #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. @@ -318,10 +333,12 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, } 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; @@ -355,8 +372,10 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, 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)) { @@ -364,10 +383,21 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, 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; @@ -378,12 +408,27 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, 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++; + } } } @@ -391,8 +436,15 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, { 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. @@ -408,10 +460,7 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, 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) { @@ -419,7 +468,9 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, 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; @@ -440,6 +491,16 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, 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; @@ -514,6 +575,480 @@ VLIB_NODE_FN (srv6_end_m_gtp4_e) (vlib_main_t * vm, 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 = @@ -522,8 +1057,20 @@ VLIB_REGISTER_NODE (srv6_end_m_gtp4_e) = 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 @@ -613,31 +1160,62 @@ VLIB_NODE_FN (srv6_end_m_gtp6_e) (vlib_main_t * vm, 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; @@ -648,8 +1226,15 @@ VLIB_NODE_FN (srv6_end_m_gtp6_e) (vlib_main_t * vm, { 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); @@ -662,10 +1247,7 @@ VLIB_NODE_FN (srv6_end_m_gtp6_e) (vlib_main_t * vm, 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) { @@ -673,6 +1255,7 @@ VLIB_NODE_FN (srv6_end_m_gtp6_e) (vlib_main_t * vm, 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; @@ -694,6 +1277,16 @@ VLIB_NODE_FN (srv6_end_m_gtp6_e) (vlib_main_t * vm, 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 @@ -791,6 +1384,8 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, u8 gtpu_type = 0; u8 qfi; u8 *qfip = NULL; + u16 seq = 0; + u8 *seqp; u32 offset, shift; u32 hdrlen; ip6_header_t *encap = NULL; @@ -838,10 +1433,15 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, 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. @@ -867,7 +1467,17 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, 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 = @@ -886,11 +1496,25 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, { 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) @@ -971,17 +1595,51 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, 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)) { @@ -1022,20 +1680,13 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, } 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 { @@ -1049,7 +1700,7 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, { 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]); @@ -1097,7 +1748,7 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d) (vlib_main_t * vm, } else if (ls_param->nhtype == SRV6_NHTYPE_NON_IP) { - ip6srv->ip.protocol = IP_PROTOCOL_NONE; + ip6srv->ip.protocol = IP_PROTOCOL_IP6_ETHERNET; } } } @@ -1186,6 +1837,8 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm, 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; @@ -1234,10 +1887,15 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm, 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. @@ -1261,7 +1919,16 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm, 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) { @@ -1281,11 +1948,25 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm, { 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) @@ -1357,13 +2038,54 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm, 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 { @@ -1373,12 +2095,18 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm, 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 = @@ -1424,26 +2152,12 @@ VLIB_NODE_FN (srv6_end_m_gtp6_d_di) (vlib_main_t * vm, } 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++; @@ -1496,8 +2210,8 @@ VLIB_REGISTER_NODE (srv6_end_m_gtp6_e) = 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) = @@ -1508,8 +2222,8 @@ 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) =