[PATCH v4 4/5] tcp: Update TCP checksum using an iovec array

[Laurent Vivier <lvivier@redhat.com>]

TCP header and payload are supposed to be in the same buffer,
and tcp_update_check_tcp4()/tcp_update_check_tcp6() compute
the checksum from the base address of the header using the
length of the IP payload.

In the future (for vhost-user) we need to dispatch the TCP header and
the TCP payload through several buffers. To be able to manage that, we
provide an iovec array that points to the data of the TCP frame.
We provide also an offset to be able to provide an array that contains
the TCP frame embedded in an lower level frame, and this offset points
to the TCP header inside the iovec array.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>
---

Notes:
    v4:
      - replace die() by err() in tcp_update_check_tcp6() too
    
    v3:
      - replace die() by err() and return
      - add more information in the error message
    
    v2:
      - s/payload_offset/l4offset/
      - check memory address of the checksum (alignment, iovec boundaries)

 checksum.c |   1 -
 tcp.c      | 138 ++++++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 110 insertions(+), 29 deletions(-)

diff --git a/checksum.c b/checksum.c
index 16b834641604..19579323cf1e 100644
--- a/checksum.c
+++ b/checksum.c
@@ -503,7 +503,6 @@ uint16_t csum(const void *buf, size_t len, uint32_t init)
  *
  * Return: 16-bit folded, complemented checksum
  */
-/* cppcheck-suppress unusedFunction */
 uint16_t csum_iov(const struct iovec *iov, size_t n, size_t offset,
 		  uint32_t init)
 {
diff --git a/tcp.c b/tcp.c
index c9472d905520..9db2e283d571 100644
--- a/tcp.c
+++ b/tcp.c
@@ -755,36 +755,103 @@ static void tcp_sock_set_bufsize(const struct ctx *c, int s)
 }
 
 /**
- * tcp_update_check_tcp4() - Update TCP checksum from stored one
- * @iph:	IPv4 header
- * @bp:		TCP header followed by TCP payload
- */
-static void tcp_update_check_tcp4(const struct iphdr *iph,
-				  struct tcp_payload_t *bp)
+ * tcp_update_check_tcp4() - Calculate TCP checksum for IPv6
+ * @src:	IPv4 source address
+ * @dst:	IPv4 destination address
+ * @iov:	Pointer to the array of IO vectors
+ * @iov_cnt:	Length of the array
+ * @l4offset:	IPv4 payload offset in the iovec array
+ */
+void tcp_update_check_tcp4(struct in_addr src,
+			   struct in_addr dst,
+			   const struct iovec *iov, int iov_cnt,
+			   size_t l4offset)
 {
-	uint16_t l4len = ntohs(iph->tot_len) - sizeof(struct iphdr);
-	struct in_addr saddr = { .s_addr = iph->saddr };
-	struct in_addr daddr = { .s_addr = iph->daddr };
-	uint32_t sum = proto_ipv4_header_psum(l4len, IPPROTO_TCP, saddr, daddr);
+	size_t check_ofs;
+	__sum16 *check;
+	int check_idx;
+	uint32_t sum;
+
+	sum = proto_ipv4_header_psum(iov_size(iov, iov_cnt) - l4offset,
+				     IPPROTO_TCP, src, dst);
+
+	check_idx = iov_skip_bytes(iov, iov_cnt,
+				   l4offset + offsetof(struct tcphdr, check),
+				   &check_ofs);
+
+	if (check_idx >= iov_cnt) {
+		err("TCP4 buffer is too small, iov size %zd, check offset %zd",
+		    iov_size(iov, iov_cnt),
+		    l4offset + offsetof(struct tcphdr, check));
+		return;
+	}
+
+	if (check_ofs + sizeof(*check) > iov[check_idx].iov_len) {
+		err("TCP4 checksum field memory is not contiguous "
+		    "check_ofs %zd check_idx %d iov_len %zd",
+		    check_ofs, check_idx, iov[check_idx].iov_len);
+		return;
+	}
+
+	check = (__sum16 *)((char *)iov[check_idx].iov_base + check_ofs);
 
-	bp->th.check = 0;
-	bp->th.check = csum(bp, l4len, sum);
+	if ((uintptr_t)check & (__alignof__(*check) - 1)) {
+		err("TCP4 checksum field is not correctly aligned in memory");
+		return;
+	}
+
+	*check = 0;
+	*check = csum_iov(iov, iov_cnt, l4offset, sum);
 }
 
 /**
  * tcp_update_check_tcp6() - Calculate TCP checksum for IPv6
- * @ip6h:	IPv6 header
- * @bp:		TCP header followed by TCP payload
- */
-static void tcp_update_check_tcp6(const struct ipv6hdr *ip6h,
-				  struct tcp_payload_t *bp)
+ * @src:	IPv6 source address
+ * @dst:	IPv6 destination address
+ * @iov:	Pointer to the array of IO vectors
+ * @iov_cnt:	Length of the array
+ * @l4offset:	IPv6 payload offset in the iovec array
+ */
+void tcp_update_check_tcp6(const struct in6_addr *src,
+			   const struct in6_addr *dst,
+			   const struct iovec *iov, int iov_cnt,
+			   size_t l4offset)
 {
-	uint16_t l4len = ntohs(ip6h->payload_len);
-	uint32_t sum = proto_ipv6_header_psum(l4len, IPPROTO_TCP,
-					      &ip6h->saddr, &ip6h->daddr);
+	size_t check_ofs;
+	__sum16 *check;
+	int check_idx;
+	uint32_t sum;
+
+	sum = proto_ipv6_header_psum(iov_size(iov, iov_cnt) - l4offset,
+				     IPPROTO_TCP, src, dst);
+
+	check_idx = iov_skip_bytes(iov, iov_cnt,
+				   l4offset + offsetof(struct tcphdr, check),
+				   &check_ofs);
+
+	if (check_idx >= iov_cnt) {
+		err("TCP6 buffer is too small, iov size %zd, check offset %zd",
+		    iov_size(iov, iov_cnt),
+		    l4offset + offsetof(struct tcphdr, check));
+		return;
+	}
 
-	bp->th.check = 0;
-	bp->th.check = csum(bp, l4len, sum);
+	if (check_ofs + sizeof(*check) > iov[check_idx].iov_len) {
+		err("TCP6 checksum field memory is not contiguous "
+		    "check_ofs %zd check_idx %d iov_len %zd",
+		    check_ofs, check_idx, iov[check_idx].iov_len);
+		return;
+	}
+
+	check = (__sum16 *)((char *)iov[check_idx].iov_base + check_ofs);
+
+	if ((uintptr_t)check & (__alignof__(*check) - 1)) {
+		err("TCP6 checksum field is not correctly aligned in memory");
+		return;
+	}
+
+	*check = 0;
+	*check = csum_iov(iov, iov_cnt, l4offset, sum);
 }
 
 /**
@@ -935,10 +1002,18 @@ static size_t tcp_fill_headers4(const struct tcp_tap_conn *conn,
 
 	tcp_fill_header(&bp->th, conn, seq);
 
-	if (no_tcp_csum)
+	if (no_tcp_csum) {
 		bp->th.check = 0;
-	else
-		tcp_update_check_tcp4(iph, bp);
+	} else {
+		const struct iovec iov = {
+			.iov_base = bp,
+			.iov_len = ntohs(iph->tot_len) - sizeof(struct iphdr),
+		};
+		struct in_addr saddr = { .s_addr = iph->saddr };
+		struct in_addr daddr = { .s_addr = iph->daddr };
+
+		tcp_update_check_tcp4(saddr, daddr, &iov, 1, 0);
+	}
 
 	tap_hdr_update(taph, l3len + sizeof(struct ethhdr));
 
@@ -980,10 +1055,17 @@ static size_t tcp_fill_headers6(const struct tcp_tap_conn *conn,
 
 	tcp_fill_header(&bp->th, conn, seq);
 
-	if (no_tcp_csum)
+	if (no_tcp_csum) {
 		bp->th.check = 0;
-	else
-		tcp_update_check_tcp6(ip6h, bp);
+	} else {
+		const struct iovec iov = {
+			.iov_base = bp,
+			.iov_len = ntohs(ip6h->payload_len)
+		};
+
+		tcp_update_check_tcp6(&ip6h->saddr, &ip6h->daddr,
+				      &iov, 1, 0);
+	}
 
 	tap_hdr_update(taph, l4len + sizeof(*ip6h) + sizeof(struct ethhdr));
 
-- 
@@ -755,36 +755,103 @@ static void tcp_sock_set_bufsize(const struct ctx *c, int s)
 }
 
 /**
- * tcp_update_check_tcp4() - Update TCP checksum from stored one
- * @iph:	IPv4 header
- * @bp:		TCP header followed by TCP payload
- */
-static void tcp_update_check_tcp4(const struct iphdr *iph,
-				  struct tcp_payload_t *bp)
+ * tcp_update_check_tcp4() - Calculate TCP checksum for IPv6
+ * @src:	IPv4 source address
+ * @dst:	IPv4 destination address
+ * @iov:	Pointer to the array of IO vectors
+ * @iov_cnt:	Length of the array
+ * @l4offset:	IPv4 payload offset in the iovec array
+ */
+void tcp_update_check_tcp4(struct in_addr src,
+			   struct in_addr dst,
+			   const struct iovec *iov, int iov_cnt,
+			   size_t l4offset)
 {
-	uint16_t l4len = ntohs(iph->tot_len) - sizeof(struct iphdr);
-	struct in_addr saddr = { .s_addr = iph->saddr };
-	struct in_addr daddr = { .s_addr = iph->daddr };
-	uint32_t sum = proto_ipv4_header_psum(l4len, IPPROTO_TCP, saddr, daddr);
+	size_t check_ofs;
+	__sum16 *check;
+	int check_idx;
+	uint32_t sum;
+
+	sum = proto_ipv4_header_psum(iov_size(iov, iov_cnt) - l4offset,
+				     IPPROTO_TCP, src, dst);
+
+	check_idx = iov_skip_bytes(iov, iov_cnt,
+				   l4offset + offsetof(struct tcphdr, check),
+				   &check_ofs);
+
+	if (check_idx >= iov_cnt) {
+		err("TCP4 buffer is too small, iov size %zd, check offset %zd",
+		    iov_size(iov, iov_cnt),
+		    l4offset + offsetof(struct tcphdr, check));
+		return;
+	}
+
+	if (check_ofs + sizeof(*check) > iov[check_idx].iov_len) {
+		err("TCP4 checksum field memory is not contiguous "
+		    "check_ofs %zd check_idx %d iov_len %zd",
+		    check_ofs, check_idx, iov[check_idx].iov_len);
+		return;
+	}
+
+	check = (__sum16 *)((char *)iov[check_idx].iov_base + check_ofs);
 
-	bp->th.check = 0;
-	bp->th.check = csum(bp, l4len, sum);
+	if ((uintptr_t)check & (__alignof__(*check) - 1)) {
+		err("TCP4 checksum field is not correctly aligned in memory");
+		return;
+	}
+
+	*check = 0;
+	*check = csum_iov(iov, iov_cnt, l4offset, sum);
 }
 
 /**
  * tcp_update_check_tcp6() - Calculate TCP checksum for IPv6
- * @ip6h:	IPv6 header
- * @bp:		TCP header followed by TCP payload
- */
-static void tcp_update_check_tcp6(const struct ipv6hdr *ip6h,
-				  struct tcp_payload_t *bp)
+ * @src:	IPv6 source address
+ * @dst:	IPv6 destination address
+ * @iov:	Pointer to the array of IO vectors
+ * @iov_cnt:	Length of the array
+ * @l4offset:	IPv6 payload offset in the iovec array
+ */
+void tcp_update_check_tcp6(const struct in6_addr *src,
+			   const struct in6_addr *dst,
+			   const struct iovec *iov, int iov_cnt,
+			   size_t l4offset)
 {
-	uint16_t l4len = ntohs(ip6h->payload_len);
-	uint32_t sum = proto_ipv6_header_psum(l4len, IPPROTO_TCP,
-					      &ip6h->saddr, &ip6h->daddr);
+	size_t check_ofs;
+	__sum16 *check;
+	int check_idx;
+	uint32_t sum;
+
+	sum = proto_ipv6_header_psum(iov_size(iov, iov_cnt) - l4offset,
+				     IPPROTO_TCP, src, dst);
+
+	check_idx = iov_skip_bytes(iov, iov_cnt,
+				   l4offset + offsetof(struct tcphdr, check),
+				   &check_ofs);
+
+	if (check_idx >= iov_cnt) {
+		err("TCP6 buffer is too small, iov size %zd, check offset %zd",
+		    iov_size(iov, iov_cnt),
+		    l4offset + offsetof(struct tcphdr, check));
+		return;
+	}
 
-	bp->th.check = 0;
-	bp->th.check = csum(bp, l4len, sum);
+	if (check_ofs + sizeof(*check) > iov[check_idx].iov_len) {
+		err("TCP6 checksum field memory is not contiguous "
+		    "check_ofs %zd check_idx %d iov_len %zd",
+		    check_ofs, check_idx, iov[check_idx].iov_len);
+		return;
+	}
+
+	check = (__sum16 *)((char *)iov[check_idx].iov_base + check_ofs);
+
+	if ((uintptr_t)check & (__alignof__(*check) - 1)) {
+		err("TCP6 checksum field is not correctly aligned in memory");
+		return;
+	}
+
+	*check = 0;
+	*check = csum_iov(iov, iov_cnt, l4offset, sum);
 }
 
 /**
@@ -935,10 +1002,18 @@ static size_t tcp_fill_headers4(const struct tcp_tap_conn *conn,
 
 	tcp_fill_header(&bp->th, conn, seq);
 
-	if (no_tcp_csum)
+	if (no_tcp_csum) {
 		bp->th.check = 0;
-	else
-		tcp_update_check_tcp4(iph, bp);
+	} else {
+		const struct iovec iov = {
+			.iov_base = bp,
+			.iov_len = ntohs(iph->tot_len) - sizeof(struct iphdr),
+		};
+		struct in_addr saddr = { .s_addr = iph->saddr };
+		struct in_addr daddr = { .s_addr = iph->daddr };
+
+		tcp_update_check_tcp4(saddr, daddr, &iov, 1, 0);
+	}
 
 	tap_hdr_update(taph, l3len + sizeof(struct ethhdr));
 
@@ -980,10 +1055,17 @@ static size_t tcp_fill_headers6(const struct tcp_tap_conn *conn,
 
 	tcp_fill_header(&bp->th, conn, seq);
 
-	if (no_tcp_csum)
+	if (no_tcp_csum) {
 		bp->th.check = 0;
-	else
-		tcp_update_check_tcp6(ip6h, bp);
+	} else {
+		const struct iovec iov = {
+			.iov_base = bp,
+			.iov_len = ntohs(ip6h->payload_len)
+		};
+
+		tcp_update_check_tcp6(&ip6h->saddr, &ip6h->daddr,
+				      &iov, 1, 0);
+	}
 
 	tap_hdr_update(taph, l4len + sizeof(*ip6h) + sizeof(struct ethhdr));
 
-- 
2.46.0