doc: add Meson coding style to contributors guide

[dpdk.git] / lib / librte_net / rte_net.c

diff --git a/lib/librte_net/rte_net.c b/lib/librte_net/rte_net.c
index 5551cce..d680acc 100644 (file)
--- a/lib/librte_net/rte_net.c
+++ b/lib/librte_net/rte_net.c
@@ -15,6 +15,7 @@
 #include <rte_gre.h>
 #include <rte_mpls.h>
 #include <rte_net.h>
+#include <rte_os_shim.h>
 
 /* get l3 packet type from ip6 next protocol */
 static uint32_t
@@ -140,8 +141,8 @@ ptype_tunnel(uint16_t *proto, const struct rte_mbuf *m,
                        [0xa] = 12,
                        [0xb] = 16,
                };
-               const struct gre_hdr *gh;
-               struct gre_hdr gh_copy;
+               const struct rte_gre_hdr *gh;
+               struct rte_gre_hdr gh_copy;
                uint16_t flags;
 
                gh = rte_pktmbuf_read(m, *off, sizeof(*gh), &gh_copy);
@@ -161,25 +162,18 @@ ptype_tunnel(uint16_t *proto, const struct rte_mbuf *m,
                        return RTE_PTYPE_TUNNEL_GRE;
        }
        case IPPROTO_IPIP:
-               *proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv4);
+               *proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
                return RTE_PTYPE_TUNNEL_IP;
        case IPPROTO_IPV6:
-               *proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv6);
+               *proto = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
                return RTE_PTYPE_TUNNEL_IP; /* IP is also valid for IPv6 */
        default:
                return 0;
        }
 }
 
-/* get the ipv4 header length */
-static uint8_t
-ip4_hlen(const struct ipv4_hdr *hdr)
-{
-       return (hdr->version_ihl & 0xf) * 4;
-}
-
 /* parse ipv6 extended headers, update offset and return next proto */
-int __rte_experimental
+int
 rte_net_skip_ip6_ext(uint16_t proto, const struct rte_mbuf *m, uint32_t *off,
        int *frag)
 {
@@ -249,7 +243,7 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
        if ((layers & RTE_PTYPE_L2_MASK) == 0)
                return 0;
 
-       if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv4))
+       if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4))
                goto l3; /* fast path if packet is IPv4 */
 
        if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN)) {
@@ -278,8 +272,8 @@ uint32_t rte_net_get_ptype(const struct rte_mbuf *m,
        } else if ((proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_MPLS)) ||
                (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_MPLSM))) {
                unsigned int i;
-               const struct mpls_hdr *mh;
-               struct mpls_hdr mh_copy;
+               const struct rte_mpls_hdr *mh;
+               struct rte_mpls_hdr mh_copy;
 
 #define MAX_MPLS_HDR 5
                for (i = 0; i < MAX_MPLS_HDR; i++) {
@@ -299,32 +293,32 @@ l3:
        if ((layers & RTE_PTYPE_L3_MASK) == 0)
                return pkt_type;
 
-       if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv4)) {
-               const struct ipv4_hdr *ip4h;
-               struct ipv4_hdr ip4h_copy;
+       if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
+               const struct rte_ipv4_hdr *ip4h;
+               struct rte_ipv4_hdr ip4h_copy;
 
                ip4h = rte_pktmbuf_read(m, off, sizeof(*ip4h), &ip4h_copy);
                if (unlikely(ip4h == NULL))
                        return pkt_type;
 
                pkt_type |= ptype_l3_ip(ip4h->version_ihl);
-               hdr_lens->l3_len = ip4_hlen(ip4h);
+               hdr_lens->l3_len = rte_ipv4_hdr_len(ip4h);
                off += hdr_lens->l3_len;
 
                if ((layers & RTE_PTYPE_L4_MASK) == 0)
                        return pkt_type;
 
                if (ip4h->fragment_offset & rte_cpu_to_be_16(
-                               IPV4_HDR_OFFSET_MASK | IPV4_HDR_MF_FLAG)) {
+                               RTE_IPV4_HDR_OFFSET_MASK | RTE_IPV4_HDR_MF_FLAG)) {
                        pkt_type |= RTE_PTYPE_L4_FRAG;
                        hdr_lens->l4_len = 0;
                        return pkt_type;
                }
                proto = ip4h->next_proto_id;
                pkt_type |= ptype_l4(proto);
-       } else if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv6)) {
-               const struct ipv6_hdr *ip6h;
-               struct ipv6_hdr ip6h_copy;
+       } else if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6)) {
+               const struct rte_ipv6_hdr *ip6h;
+               struct rte_ipv6_hdr ip6h_copy;
                int frag = 0;
 
                ip6h = rte_pktmbuf_read(m, off, sizeof(*ip6h), &ip6h_copy);
@@ -357,11 +351,11 @@ l3:
        }
 
        if ((pkt_type & RTE_PTYPE_L4_MASK) == RTE_PTYPE_L4_UDP) {
-               hdr_lens->l4_len = sizeof(struct udp_hdr);
+               hdr_lens->l4_len = sizeof(struct rte_udp_hdr);
                return pkt_type;
        } else if ((pkt_type & RTE_PTYPE_L4_MASK) == RTE_PTYPE_L4_TCP) {
-               const struct tcp_hdr *th;
-               struct tcp_hdr th_copy;
+               const struct rte_tcp_hdr *th;
+               struct rte_tcp_hdr th_copy;
 
                th = rte_pktmbuf_read(m, off, sizeof(*th), &th_copy);
                if (unlikely(th == NULL))
@@ -370,7 +364,7 @@ l3:
                hdr_lens->l4_len = (th->data_off & 0xf0) >> 2;
                return pkt_type;
        } else if ((pkt_type & RTE_PTYPE_L4_MASK) == RTE_PTYPE_L4_SCTP) {
-               hdr_lens->l4_len = sizeof(struct sctp_hdr);
+               hdr_lens->l4_len = sizeof(struct rte_sctp_hdr);
                return pkt_type;
        } else {
                uint32_t prev_off = off;
@@ -431,32 +425,32 @@ l3:
        if ((layers & RTE_PTYPE_INNER_L3_MASK) == 0)
                return pkt_type;
 
-       if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv4)) {
-               const struct ipv4_hdr *ip4h;
-               struct ipv4_hdr ip4h_copy;
+       if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4)) {
+               const struct rte_ipv4_hdr *ip4h;
+               struct rte_ipv4_hdr ip4h_copy;
 
                ip4h = rte_pktmbuf_read(m, off, sizeof(*ip4h), &ip4h_copy);
                if (unlikely(ip4h == NULL))
                        return pkt_type;
 
                pkt_type |= ptype_inner_l3_ip(ip4h->version_ihl);
-               hdr_lens->inner_l3_len = ip4_hlen(ip4h);
+               hdr_lens->inner_l3_len = rte_ipv4_hdr_len(ip4h);
                off += hdr_lens->inner_l3_len;
 
                if ((layers & RTE_PTYPE_INNER_L4_MASK) == 0)
                        return pkt_type;
                if (ip4h->fragment_offset &
-                               rte_cpu_to_be_16(IPV4_HDR_OFFSET_MASK |
-                                       IPV4_HDR_MF_FLAG)) {
+                               rte_cpu_to_be_16(RTE_IPV4_HDR_OFFSET_MASK |
+                                       RTE_IPV4_HDR_MF_FLAG)) {
                        pkt_type |= RTE_PTYPE_INNER_L4_FRAG;
                        hdr_lens->inner_l4_len = 0;
                        return pkt_type;
                }
                proto = ip4h->next_proto_id;
                pkt_type |= ptype_inner_l4(proto);
-       } else if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv6)) {
-               const struct ipv6_hdr *ip6h;
-               struct ipv6_hdr ip6h_copy;
+       } else if (proto == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6)) {
+               const struct rte_ipv6_hdr *ip6h;
+               struct rte_ipv6_hdr ip6h_copy;
                int frag = 0;
 
                ip6h = rte_pktmbuf_read(m, off, sizeof(*ip6h), &ip6h_copy);
@@ -493,11 +487,11 @@ l3:
        }
 
        if ((pkt_type & RTE_PTYPE_INNER_L4_MASK) == RTE_PTYPE_INNER_L4_UDP) {
-               hdr_lens->inner_l4_len = sizeof(struct udp_hdr);
+               hdr_lens->inner_l4_len = sizeof(struct rte_udp_hdr);
        } else if ((pkt_type & RTE_PTYPE_INNER_L4_MASK) ==
                        RTE_PTYPE_INNER_L4_TCP) {
-               const struct tcp_hdr *th;
-               struct tcp_hdr th_copy;
+               const struct rte_tcp_hdr *th;
+               struct rte_tcp_hdr th_copy;
 
                th = rte_pktmbuf_read(m, off, sizeof(*th), &th_copy);
                if (unlikely(th == NULL))
@@ -506,7 +500,7 @@ l3:
                hdr_lens->inner_l4_len = (th->data_off & 0xf0) >> 2;
        } else if ((pkt_type & RTE_PTYPE_INNER_L4_MASK) ==
                        RTE_PTYPE_INNER_L4_SCTP) {
-               hdr_lens->inner_l4_len = sizeof(struct sctp_hdr);
+               hdr_lens->inner_l4_len = sizeof(struct rte_sctp_hdr);
        } else {
                hdr_lens->inner_l4_len = 0;
        }