DPDK  22.11.0
rte_ip.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 1982, 1986, 1990, 1993
3  * The Regents of the University of California.
4  * Copyright(c) 2010-2014 Intel Corporation.
5  * Copyright(c) 2014 6WIND S.A.
6  * All rights reserved.
7  */
8 
9 #ifndef _RTE_IP_H_
10 #define _RTE_IP_H_
11 
18 #include <stdint.h>
19 
20 #ifdef RTE_EXEC_ENV_WINDOWS
21 #include <ws2tcpip.h>
22 #else
23 #include <sys/socket.h>
24 #include <sys/types.h>
25 #include <netinet/in.h>
26 #include <arpa/inet.h>
27 #include <netinet/ip.h>
28 #include <netinet/ip6.h>
29 #endif
30 
31 #include <rte_compat.h>
32 #include <rte_byteorder.h>
33 #include <rte_mbuf.h>
34 
35 #ifdef __cplusplus
36 extern "C" {
37 #endif
38 
42 struct rte_ipv4_hdr {
43  __extension__
44  union {
45  uint8_t version_ihl;
46  struct {
47 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
48  uint8_t ihl:4;
49  uint8_t version:4;
50 #elif RTE_BYTE_ORDER == RTE_BIG_ENDIAN
51  uint8_t version:4;
52  uint8_t ihl:4;
53 #endif
54  };
55  };
56  uint8_t type_of_service;
60  uint8_t time_to_live;
61  uint8_t next_proto_id;
65 } __rte_packed;
66 
68 #define RTE_IPV4(a, b, c, d) ((uint32_t)(((a) & 0xff) << 24) | \
69  (((b) & 0xff) << 16) | \
70  (((c) & 0xff) << 8) | \
71  ((d) & 0xff))
72 
74 #define RTE_IPV4_MAX_PKT_LEN 65535
75 
77 #define RTE_IPV4_HDR_IHL_MASK (0x0f)
78 
82 #define RTE_IPV4_IHL_MULTIPLIER (4)
83 
84 /* Type of Service fields */
85 #define RTE_IPV4_HDR_DSCP_MASK (0xfc)
86 #define RTE_IPV4_HDR_ECN_MASK (0x03)
87 #define RTE_IPV4_HDR_ECN_CE RTE_IPV4_HDR_ECN_MASK
88 
89 /* Fragment Offset * Flags. */
90 #define RTE_IPV4_HDR_DF_SHIFT 14
91 #define RTE_IPV4_HDR_MF_SHIFT 13
92 #define RTE_IPV4_HDR_FO_SHIFT 3
93 
94 #define RTE_IPV4_HDR_DF_FLAG (1 << RTE_IPV4_HDR_DF_SHIFT)
95 #define RTE_IPV4_HDR_MF_FLAG (1 << RTE_IPV4_HDR_MF_SHIFT)
96 
97 #define RTE_IPV4_HDR_OFFSET_MASK ((1 << RTE_IPV4_HDR_MF_SHIFT) - 1)
98 
99 #define RTE_IPV4_HDR_OFFSET_UNITS 8
100 
101 /* IPv4 options */
102 #define RTE_IPV4_HDR_OPT_EOL 0
103 #define RTE_IPV4_HDR_OPT_NOP 1
104 #define RTE_IPV4_HDR_OPT_COPIED(v) ((v) & 0x80)
105 #define RTE_IPV4_HDR_OPT_MAX_LEN 40
106 
107 /*
108  * IPv4 address types
109  */
110 #define RTE_IPV4_ANY ((uint32_t)0x00000000)
111 #define RTE_IPV4_LOOPBACK ((uint32_t)0x7f000001)
112 #define RTE_IPV4_BROADCAST ((uint32_t)0xe0000000)
113 #define RTE_IPV4_ALLHOSTS_GROUP ((uint32_t)0xe0000001)
114 #define RTE_IPV4_ALLRTRS_GROUP ((uint32_t)0xe0000002)
115 #define RTE_IPV4_MAX_LOCAL_GROUP ((uint32_t)0xe00000ff)
117 /*
118  * IPv4 Multicast-related macros
119  */
120 #define RTE_IPV4_MIN_MCAST \
121  RTE_IPV4(224, 0, 0, 0)
122 #define RTE_IPV4_MAX_MCAST \
123  RTE_IPV4(239, 255, 255, 255)
125 #define RTE_IS_IPV4_MCAST(x) \
126  ((x) >= RTE_IPV4_MIN_MCAST && (x) <= RTE_IPV4_MAX_MCAST)
127 
129 /* IPv4 default fields values */
130 #define RTE_IPV4_MIN_IHL (0x5)
131 #define RTE_IPV4_VHL_DEF ((IPVERSION << 4) | RTE_IPV4_MIN_IHL)
132 
141 static inline uint8_t
142 rte_ipv4_hdr_len(const struct rte_ipv4_hdr *ipv4_hdr)
143 {
144  return (uint8_t)((ipv4_hdr->version_ihl & RTE_IPV4_HDR_IHL_MASK) *
146 }
147 
161 static inline uint32_t
162 __rte_raw_cksum(const void *buf, size_t len, uint32_t sum)
163 {
164  const void *end;
165 
166  for (end = RTE_PTR_ADD(buf, RTE_ALIGN_FLOOR(len, sizeof(uint16_t)));
167  buf != end; buf = RTE_PTR_ADD(buf, sizeof(uint16_t))) {
168  uint16_t v;
169 
170  memcpy(&v, buf, sizeof(uint16_t));
171  sum += v;
172  }
173 
174  /* if length is odd, keeping it byte order independent */
175  if (unlikely(len % 2)) {
176  uint16_t left = 0;
177 
178  memcpy(&left, end, 1);
179  sum += left;
180  }
181 
182  return sum;
183 }
184 
194 static inline uint16_t
195 __rte_raw_cksum_reduce(uint32_t sum)
196 {
197  sum = ((sum & 0xffff0000) >> 16) + (sum & 0xffff);
198  sum = ((sum & 0xffff0000) >> 16) + (sum & 0xffff);
199  return (uint16_t)sum;
200 }
201 
212 static inline uint16_t
213 rte_raw_cksum(const void *buf, size_t len)
214 {
215  uint32_t sum;
216 
217  sum = __rte_raw_cksum(buf, len, 0);
218  return __rte_raw_cksum_reduce(sum);
219 }
220 
235 static inline int
236 rte_raw_cksum_mbuf(const struct rte_mbuf *m, uint32_t off, uint32_t len,
237  uint16_t *cksum)
238 {
239  const struct rte_mbuf *seg;
240  const char *buf;
241  uint32_t sum, tmp;
242  uint32_t seglen, done;
243 
244  /* easy case: all data in the first segment */
245  if (off + len <= rte_pktmbuf_data_len(m)) {
247  const char *, off), len);
248  return 0;
249  }
250 
251  if (unlikely(off + len > rte_pktmbuf_pkt_len(m)))
252  return -1; /* invalid params, return a dummy value */
253 
254  /* else browse the segment to find offset */
255  seglen = 0;
256  for (seg = m; seg != NULL; seg = seg->next) {
257  seglen = rte_pktmbuf_data_len(seg);
258  if (off < seglen)
259  break;
260  off -= seglen;
261  }
262  RTE_ASSERT(seg != NULL);
263  if (seg == NULL)
264  return -1;
265  seglen -= off;
266  buf = rte_pktmbuf_mtod_offset(seg, const char *, off);
267  if (seglen >= len) {
268  /* all in one segment */
269  *cksum = rte_raw_cksum(buf, len);
270  return 0;
271  }
272 
273  /* hard case: process checksum of several segments */
274  sum = 0;
275  done = 0;
276  for (;;) {
277  tmp = __rte_raw_cksum(buf, seglen, 0);
278  if (done & 1)
279  tmp = rte_bswap16((uint16_t)tmp);
280  sum += tmp;
281  done += seglen;
282  if (done == len)
283  break;
284  seg = seg->next;
285  buf = rte_pktmbuf_mtod(seg, const char *);
286  seglen = rte_pktmbuf_data_len(seg);
287  if (seglen > len - done)
288  seglen = len - done;
289  }
290 
291  *cksum = __rte_raw_cksum_reduce(sum);
292  return 0;
293 }
294 
305 static inline uint16_t
306 rte_ipv4_cksum(const struct rte_ipv4_hdr *ipv4_hdr)
307 {
308  uint16_t cksum;
309  cksum = rte_raw_cksum(ipv4_hdr, rte_ipv4_hdr_len(ipv4_hdr));
310  return (uint16_t)~cksum;
311 }
312 
331 static inline uint16_t
332 rte_ipv4_phdr_cksum(const struct rte_ipv4_hdr *ipv4_hdr, uint64_t ol_flags)
333 {
334  struct ipv4_psd_header {
335  uint32_t src_addr; /* IP address of source host. */
336  uint32_t dst_addr; /* IP address of destination host. */
337  uint8_t zero; /* zero. */
338  uint8_t proto; /* L4 protocol type. */
339  uint16_t len; /* L4 length. */
340  } psd_hdr;
341 
342  uint32_t l3_len;
343 
344  psd_hdr.src_addr = ipv4_hdr->src_addr;
345  psd_hdr.dst_addr = ipv4_hdr->dst_addr;
346  psd_hdr.zero = 0;
347  psd_hdr.proto = ipv4_hdr->next_proto_id;
348  if (ol_flags & RTE_MBUF_F_TX_TCP_SEG) {
349  psd_hdr.len = 0;
350  } else {
351  l3_len = rte_be_to_cpu_16(ipv4_hdr->total_length);
352  psd_hdr.len = rte_cpu_to_be_16((uint16_t)(l3_len -
353  rte_ipv4_hdr_len(ipv4_hdr)));
354  }
355  return rte_raw_cksum(&psd_hdr, sizeof(psd_hdr));
356 }
357 
361 static inline uint16_t
362 __rte_ipv4_udptcp_cksum(const struct rte_ipv4_hdr *ipv4_hdr, const void *l4_hdr)
363 {
364  uint32_t cksum;
365  uint32_t l3_len, l4_len;
366  uint8_t ip_hdr_len;
367 
368  ip_hdr_len = rte_ipv4_hdr_len(ipv4_hdr);
369  l3_len = rte_be_to_cpu_16(ipv4_hdr->total_length);
370  if (l3_len < ip_hdr_len)
371  return 0;
372 
373  l4_len = l3_len - ip_hdr_len;
374 
375  cksum = rte_raw_cksum(l4_hdr, l4_len);
376  cksum += rte_ipv4_phdr_cksum(ipv4_hdr, 0);
377 
378  cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff);
379 
380  return (uint16_t)cksum;
381 }
382 
395 static inline uint16_t
396 rte_ipv4_udptcp_cksum(const struct rte_ipv4_hdr *ipv4_hdr, const void *l4_hdr)
397 {
398  uint16_t cksum = __rte_ipv4_udptcp_cksum(ipv4_hdr, l4_hdr);
399 
400  cksum = ~cksum;
401 
402  /*
403  * Per RFC 768: If the computed checksum is zero for UDP,
404  * it is transmitted as all ones
405  * (the equivalent in one's complement arithmetic).
406  */
407  if (cksum == 0 && ipv4_hdr->next_proto_id == IPPROTO_UDP)
408  cksum = 0xffff;
409 
410  return cksum;
411 }
412 
416 static inline uint16_t
417 __rte_ipv4_udptcp_cksum_mbuf(const struct rte_mbuf *m,
418  const struct rte_ipv4_hdr *ipv4_hdr,
419  uint16_t l4_off)
420 {
421  uint16_t raw_cksum;
422  uint32_t cksum;
423 
424  if (l4_off > m->pkt_len)
425  return 0;
426 
427  if (rte_raw_cksum_mbuf(m, l4_off, m->pkt_len - l4_off, &raw_cksum))
428  return 0;
429 
430  cksum = raw_cksum + rte_ipv4_phdr_cksum(ipv4_hdr, 0);
431 
432  cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff);
433 
434  return (uint16_t)cksum;
435 }
436 
452 __rte_experimental
453 static inline uint16_t
454 rte_ipv4_udptcp_cksum_mbuf(const struct rte_mbuf *m,
455  const struct rte_ipv4_hdr *ipv4_hdr, uint16_t l4_off)
456 {
457  uint16_t cksum = __rte_ipv4_udptcp_cksum_mbuf(m, ipv4_hdr, l4_off);
458 
459  cksum = ~cksum;
460 
461  /*
462  * Per RFC 768: If the computed checksum is zero for UDP,
463  * it is transmitted as all ones
464  * (the equivalent in one's complement arithmetic).
465  */
466  if (cksum == 0 && ipv4_hdr->next_proto_id == IPPROTO_UDP)
467  cksum = 0xffff;
468 
469  return cksum;
470 }
471 
485 __rte_experimental
486 static inline int
487 rte_ipv4_udptcp_cksum_verify(const struct rte_ipv4_hdr *ipv4_hdr,
488  const void *l4_hdr)
489 {
490  uint16_t cksum = __rte_ipv4_udptcp_cksum(ipv4_hdr, l4_hdr);
491 
492  if (cksum != 0xffff)
493  return -1;
494 
495  return 0;
496 }
497 
516 __rte_experimental
517 static inline uint16_t
519  const struct rte_ipv4_hdr *ipv4_hdr,
520  uint16_t l4_off)
521 {
522  uint16_t cksum = __rte_ipv4_udptcp_cksum_mbuf(m, ipv4_hdr, l4_off);
523 
524  if (cksum != 0xffff)
525  return -1;
526 
527  return 0;
528 }
529 
533 struct rte_ipv6_hdr {
534  rte_be32_t vtc_flow;
535  rte_be16_t payload_len;
536  uint8_t proto;
537  uint8_t hop_limits;
538  uint8_t src_addr[16];
539  uint8_t dst_addr[16];
542 /* IPv6 vtc_flow: IPv / TC / flow_label */
543 #define RTE_IPV6_HDR_FL_SHIFT 0
544 #define RTE_IPV6_HDR_TC_SHIFT 20
545 #define RTE_IPV6_HDR_FL_MASK ((1u << RTE_IPV6_HDR_TC_SHIFT) - 1)
546 #define RTE_IPV6_HDR_TC_MASK (0xff << RTE_IPV6_HDR_TC_SHIFT)
547 #define RTE_IPV6_HDR_DSCP_MASK (0xfc << RTE_IPV6_HDR_TC_SHIFT)
548 #define RTE_IPV6_HDR_ECN_MASK (0x03 << RTE_IPV6_HDR_TC_SHIFT)
549 #define RTE_IPV6_HDR_ECN_CE RTE_IPV6_HDR_ECN_MASK
550 
551 #define RTE_IPV6_MIN_MTU 1280
569 static inline uint16_t
570 rte_ipv6_phdr_cksum(const struct rte_ipv6_hdr *ipv6_hdr, uint64_t ol_flags)
571 {
572  uint32_t sum;
573  struct {
574  rte_be32_t len; /* L4 length. */
575  rte_be32_t proto; /* L4 protocol - top 3 bytes must be zero */
576  } psd_hdr;
577 
578  psd_hdr.proto = (uint32_t)(ipv6_hdr->proto << 24);
579  if (ol_flags & RTE_MBUF_F_TX_TCP_SEG) {
580  psd_hdr.len = 0;
581  } else {
582  psd_hdr.len = ipv6_hdr->payload_len;
583  }
584 
585  sum = __rte_raw_cksum(ipv6_hdr->src_addr,
586  sizeof(ipv6_hdr->src_addr) + sizeof(ipv6_hdr->dst_addr),
587  0);
588  sum = __rte_raw_cksum(&psd_hdr, sizeof(psd_hdr), sum);
589  return __rte_raw_cksum_reduce(sum);
590 }
591 
595 static inline uint16_t
596 __rte_ipv6_udptcp_cksum(const struct rte_ipv6_hdr *ipv6_hdr, const void *l4_hdr)
597 {
598  uint32_t cksum;
599  uint32_t l4_len;
600 
601  l4_len = rte_be_to_cpu_16(ipv6_hdr->payload_len);
602 
603  cksum = rte_raw_cksum(l4_hdr, l4_len);
604  cksum += rte_ipv6_phdr_cksum(ipv6_hdr, 0);
605 
606  cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff);
607 
608  return (uint16_t)cksum;
609 }
610 
624 static inline uint16_t
625 rte_ipv6_udptcp_cksum(const struct rte_ipv6_hdr *ipv6_hdr, const void *l4_hdr)
626 {
627  uint16_t cksum = __rte_ipv6_udptcp_cksum(ipv6_hdr, l4_hdr);
628 
629  cksum = ~cksum;
630 
631  /*
632  * Per RFC 768: If the computed checksum is zero for UDP,
633  * it is transmitted as all ones
634  * (the equivalent in one's complement arithmetic).
635  */
636  if (cksum == 0 && ipv6_hdr->proto == IPPROTO_UDP)
637  cksum = 0xffff;
638 
639  return cksum;
640 }
641 
645 static inline uint16_t
646 __rte_ipv6_udptcp_cksum_mbuf(const struct rte_mbuf *m,
647  const struct rte_ipv6_hdr *ipv6_hdr,
648  uint16_t l4_off)
649 {
650  uint16_t raw_cksum;
651  uint32_t cksum;
652 
653  if (l4_off > m->pkt_len)
654  return 0;
655 
656  if (rte_raw_cksum_mbuf(m, l4_off, m->pkt_len - l4_off, &raw_cksum))
657  return 0;
658 
659  cksum = raw_cksum + rte_ipv6_phdr_cksum(ipv6_hdr, 0);
660 
661  cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff);
662 
663  return (uint16_t)cksum;
664 }
665 
684 __rte_experimental
685 static inline uint16_t
686 rte_ipv6_udptcp_cksum_mbuf(const struct rte_mbuf *m,
687  const struct rte_ipv6_hdr *ipv6_hdr, uint16_t l4_off)
688 {
689  uint16_t cksum = __rte_ipv6_udptcp_cksum_mbuf(m, ipv6_hdr, l4_off);
690 
691  cksum = ~cksum;
692 
693  /*
694  * Per RFC 768: If the computed checksum is zero for UDP,
695  * it is transmitted as all ones
696  * (the equivalent in one's complement arithmetic).
697  */
698  if (cksum == 0 && ipv6_hdr->proto == IPPROTO_UDP)
699  cksum = 0xffff;
700 
701  return cksum;
702 }
703 
718 __rte_experimental
719 static inline int
720 rte_ipv6_udptcp_cksum_verify(const struct rte_ipv6_hdr *ipv6_hdr,
721  const void *l4_hdr)
722 {
723  uint16_t cksum = __rte_ipv6_udptcp_cksum(ipv6_hdr, l4_hdr);
724 
725  if (cksum != 0xffff)
726  return -1;
727 
728  return 0;
729 }
730 
750 __rte_experimental
751 static inline int
753  const struct rte_ipv6_hdr *ipv6_hdr,
754  uint16_t l4_off)
755 {
756  uint16_t cksum = __rte_ipv6_udptcp_cksum_mbuf(m, ipv6_hdr, l4_off);
757 
758  if (cksum != 0xffff)
759  return -1;
760 
761  return 0;
762 }
763 
765 #define RTE_IPV6_EHDR_MF_SHIFT 0
766 #define RTE_IPV6_EHDR_MF_MASK 1
767 #define RTE_IPV6_EHDR_FO_SHIFT 3
768 #define RTE_IPV6_EHDR_FO_MASK (~((1 << RTE_IPV6_EHDR_FO_SHIFT) - 1))
769 #define RTE_IPV6_EHDR_FO_ALIGN (1 << RTE_IPV6_EHDR_FO_SHIFT)
770 
771 #define RTE_IPV6_FRAG_USED_MASK (RTE_IPV6_EHDR_MF_MASK | RTE_IPV6_EHDR_FO_MASK)
772 
773 #define RTE_IPV6_GET_MF(x) ((x) & RTE_IPV6_EHDR_MF_MASK)
774 #define RTE_IPV6_GET_FO(x) ((x) >> RTE_IPV6_EHDR_FO_SHIFT)
775 
776 #define RTE_IPV6_SET_FRAG_DATA(fo, mf) \
777  (((fo) & RTE_IPV6_EHDR_FO_MASK) | ((mf) & RTE_IPV6_EHDR_MF_MASK))
778 
779 struct rte_ipv6_fragment_ext {
780  uint8_t next_header;
781  uint8_t reserved;
782  rte_be16_t frag_data;
783  rte_be32_t id;
784 } __rte_packed;
785 
786 /* IPv6 fragment extension header size */
787 #define RTE_IPV6_FRAG_HDR_SIZE sizeof(struct rte_ipv6_fragment_ext)
788 
805 __rte_experimental
806 static inline int
807 rte_ipv6_get_next_ext(const uint8_t *p, int proto, size_t *ext_len)
808 {
809  int next_proto;
810 
811  switch (proto) {
812  case IPPROTO_AH:
813  next_proto = *p++;
814  *ext_len = (*p + 2) * sizeof(uint32_t);
815  break;
816 
817  case IPPROTO_HOPOPTS:
818  case IPPROTO_ROUTING:
819  case IPPROTO_DSTOPTS:
820  next_proto = *p++;
821  *ext_len = (*p + 1) * sizeof(uint64_t);
822  break;
823 
824  case IPPROTO_FRAGMENT:
825  next_proto = *p;
826  *ext_len = RTE_IPV6_FRAG_HDR_SIZE;
827  break;
828 
829  default:
830  return -EINVAL;
831  }
832 
833  return next_proto;
834 }
835 
836 #ifdef __cplusplus
837 }
838 #endif
839 
840 #endif /* _RTE_IP_H_ */
static uint8_t rte_ipv4_hdr_len(const struct rte_ipv4_hdr *ipv4_hdr)
Definition: rte_ip.h:144
struct rte_mbuf * next
#define __rte_packed
Definition: rte_common.h:83
static int rte_raw_cksum_mbuf(const struct rte_mbuf *m, uint32_t off, uint32_t len, uint16_t *cksum)
Definition: rte_ip.h:238
#define RTE_ALIGN_FLOOR(val, align)
Definition: rte_common.h:328
static uint16_t rte_ipv4_udptcp_cksum(const struct rte_ipv4_hdr *ipv4_hdr, const void *l4_hdr)
Definition: rte_ip.h:398
uint32_t rte_be32_t
uint8_t dst_addr[16]
Definition: rte_ip.h:541
rte_be16_t fragment_offset
Definition: rte_ip.h:59
uint8_t version_ihl
Definition: rte_ip.h:45
static uint16_t rte_bswap16(uint16_t _x)
static __rte_experimental int rte_ipv6_udptcp_cksum_verify(const struct rte_ipv6_hdr *ipv6_hdr, const void *l4_hdr)
Definition: rte_ip.h:722
rte_be32_t dst_addr
Definition: rte_ip.h:64
static __rte_experimental uint16_t rte_ipv4_udptcp_cksum_mbuf(const struct rte_mbuf *m, const struct rte_ipv4_hdr *ipv4_hdr, uint16_t l4_off)
Definition: rte_ip.h:456
rte_be32_t src_addr
Definition: rte_ip.h:63
static __rte_experimental uint16_t rte_ipv6_udptcp_cksum_mbuf(const struct rte_mbuf *m, const struct rte_ipv6_hdr *ipv6_hdr, uint16_t l4_off)
Definition: rte_ip.h:688
uint8_t src_addr[16]
Definition: rte_ip.h:540
static __rte_experimental int rte_ipv6_get_next_ext(const uint8_t *p, int proto, size_t *ext_len)
Definition: rte_ip.h:809
#define rte_pktmbuf_mtod_offset(m, t, o)
static __rte_experimental int rte_ipv6_udptcp_cksum_mbuf_verify(const struct rte_mbuf *m, const struct rte_ipv6_hdr *ipv6_hdr, uint16_t l4_off)
Definition: rte_ip.h:754
#define RTE_PTR_ADD(ptr, x)
Definition: rte_common.h:290
static rte_be16_t rte_cpu_to_be_16(uint16_t x)
#define unlikely(x)
static uint16_t rte_ipv4_phdr_cksum(const struct rte_ipv4_hdr *ipv4_hdr, uint64_t ol_flags)
Definition: rte_ip.h:334
static uint16_t rte_ipv6_phdr_cksum(const struct rte_ipv6_hdr *ipv6_hdr, uint64_t ol_flags)
Definition: rte_ip.h:572
#define rte_pktmbuf_mtod(m, t)
#define rte_pktmbuf_pkt_len(m)
Definition: rte_mbuf.h:1556
uint8_t type_of_service
Definition: rte_ip.h:56
uint8_t time_to_live
Definition: rte_ip.h:60
uint8_t proto
Definition: rte_ip.h:538
rte_be16_t packet_id
Definition: rte_ip.h:58
static uint16_t rte_raw_cksum(const void *buf, size_t len)
Definition: rte_ip.h:215
uint64_t ol_flags
uint32_t pkt_len
#define rte_pktmbuf_data_len(m)
Definition: rte_mbuf.h:1566
#define RTE_MBUF_F_TX_TCP_SEG
uint8_t next_proto_id
Definition: rte_ip.h:61
rte_be16_t payload_len
Definition: rte_ip.h:537
rte_be16_t total_length
Definition: rte_ip.h:57
uint8_t ihl
Definition: rte_ip.h:48
uint16_t rte_be16_t
#define RTE_IPV4_HDR_IHL_MASK
Definition: rte_ip.h:77
static uint16_t rte_be_to_cpu_16(rte_be16_t x)
static __rte_experimental int rte_ipv4_udptcp_cksum_verify(const struct rte_ipv4_hdr *ipv4_hdr, const void *l4_hdr)
Definition: rte_ip.h:489
rte_be16_t hdr_checksum
Definition: rte_ip.h:62
static uint16_t rte_ipv4_cksum(const struct rte_ipv4_hdr *ipv4_hdr)
Definition: rte_ip.h:308
static __rte_experimental uint16_t rte_ipv4_udptcp_cksum_mbuf_verify(const struct rte_mbuf *m, const struct rte_ipv4_hdr *ipv4_hdr, uint16_t l4_off)
Definition: rte_ip.h:520
uint8_t version
Definition: rte_ip.h:49
static uint16_t rte_ipv6_udptcp_cksum(const struct rte_ipv6_hdr *ipv6_hdr, const void *l4_hdr)
Definition: rte_ip.h:627
#define RTE_IPV4_IHL_MULTIPLIER
Definition: rte_ip.h:82