[Test code] Change packet lengths to sized types

IPv4 packet header sizes fit in a u8 value, and all IP/Ethernet-related
packet total sizes fit in a u16 value. This changes those sizes to use
smaller types that don't ever need to be converted to smaller types.

Signed-off-by: Jonathan Browne <[email protected]>

Author: JBYoshi

src/vmm/src/dumbo/pdu/ipv4.rs

@@ -471,7 +471,7 @@ mod tests {
     use super::*;
     use crate::dumbo::MacAddr;
 
-    const MAX_HEADER_LEN: usize = 60;
+    const MAX_HEADER_LEN: u8 = 60;
 
     #[test]
     fn test_set_get() {
@@ -532,12 +532,16 @@ mod tests {
         let buf_len = buf.len();
         // No IPv4 option support for now.
         let header_len = OPTIONS_OFFSET;
-        let payload_len = buf_len - OPTIONS_OFFSET;
+        let payload_len = buf_len - usize::from(OPTIONS_OFFSET);
 
         {
             let mut p = IPv4Packet::write_header(buf.as_mut(), PROTOCOL_TCP, src, dst)
                 .unwrap()
-                .with_header_and_payload_len_unchecked(header_len, payload_len, true);
+                .with_header_and_payload_len_unchecked(
+                    header_len,
+                    u16::try_from(payload_len).unwrap(),
+                    true,
+                );
 
             assert_eq!(p.version_and_header_len(), (IPV4_VERSION, header_len));
             assert_eq!(p.dscp_and_ecn(), (0, 0));
@@ -595,7 +599,7 @@ mod tests {
         // Total length smaller than header length.
         p(buf.as_mut())
             .set_version_and_header_len(IPV4_VERSION, OPTIONS_OFFSET)
-            .set_total_len(OPTIONS_OFFSET as u16 - 1);
+            .set_total_len(u16::from(OPTIONS_OFFSET) - 1);
         look_for_error(buf.as_ref(), Error::InvalidTotalLen);
 
         // Total len not matching slice length.
@@ -643,7 +647,7 @@ mod tests {
 
             assert_eq!(p.compute_checksum(), 0);
             assert_eq!(p.total_len() as usize, p.len());
-            assert_eq!(p.len(), header_len + payload_len);
+            assert_eq!(p.len(), usize::from(header_len) + usize::from(payload_len));
         }
 
         {
@@ -653,7 +657,7 @@ mod tests {
 
             assert_eq!(p.compute_checksum(), 0);
             assert_eq!(p.total_len() as usize, p.len());
-            assert_eq!(p.len(), header_len + payload_len);
+            assert_eq!(p.len(), usize::from(header_len) + usize::from(payload_len));
         }
     }
 

src/vmm/src/dumbo/pdu/tcp.rs

@@ -651,7 +651,7 @@ mod tests {
         let mss_option = Some(mss_left);
         let payload = Some((b.as_ref(), b.len()));
 
-        let header_len = OPTIONS_OFFSET + OPTION_LEN_MSS.into();
+        let header_len = OPTIONS_OFFSET + OPTION_LEN_MSS;
 
         let segment_len = {
             let mut segment = TcpSegment::write_segment(
@@ -688,24 +688,28 @@ mod tests {
             assert_eq!(segment.urgent_pointer(), 0);
 
             {
-                let options = segment.options_unchecked(header_len);
-                assert_eq!(options.len(), OPTION_LEN_MSS.into());
+                let options = segment.options_unchecked(header_len.into());
+                assert_eq!(options.len(), usize::from(OPTION_LEN_MSS));
                 assert_eq!(options[0], OPTION_KIND_MSS);
                 assert_eq!(options[1], OPTION_LEN_MSS);
                 assert_eq!(options.ntohs_unchecked(2), mss_left);
             }
 
             // Payload was smaller than mss_left after options.
-            assert_eq!(segment.len(), header_len + b.len());
+            assert_eq!(
+                usize::from(segment.len()),
+                usize::from(header_len) + b.len(),
+            );
             segment.len()
             // Mutable borrow of a goes out of scope.
         };
 
         {
             let segment =
-                TcpSegment::from_bytes(&a[..segment_len], Some((src_addr, dst_addr))).unwrap();
+                TcpSegment::from_bytes(&a[..segment_len.into()], Some((src_addr, dst_addr)))
+                    .unwrap();
             assert_eq!(
-                segment.parse_mss_option_unchecked(header_len),
+                segment.parse_mss_option_unchecked(header_len.into()),
                 Ok(Some(NonZeroU16::new(mss_left).unwrap()))
             );
         }
@@ -728,7 +732,7 @@ mod tests {
             .unwrap()
             .len();
 
-            assert_eq!(segment_len, mss_left as usize);
+            assert_eq!(segment_len, mss_left);
         }
 
         // Now let's test the error value for from_bytes().

src/vmm/src/dumbo/tcp/connection.rs

@@ -1110,7 +1110,7 @@ pub(crate) mod tests {
             data_buf: &[u8],
         ) -> TcpSegment<'a, &'a mut [u8]> {
             let segment = self.write_segment_helper(buf, false, Some((data_buf, data_buf.len())));
-            assert_eq!(segment.payload_len(), data_buf.len());
+            assert_eq!(usize::from(segment.payload_len()), data_buf.len());
             segment
         }
 
@@ -1203,7 +1203,7 @@ pub(crate) mod tests {
         options_len: usize,
         flags_after_ns: TcpFlags,
     ) {
-        assert_eq!(s.len(), BASIC_SEGMENT_SIZE + options_len);
+        assert_eq!(usize::from(s.len()), BASIC_SEGMENT_SIZE + options_len);
         assert_eq!(s.flags_after_ns(), flags_after_ns);
     }
 
@@ -1471,13 +1471,13 @@ pub(crate) mod tests {
         assert_eq!(
             t.receive_segment(&mut c, &data).unwrap(),
             (
-                Some(NonZeroUsize::new(data.payload_len()).unwrap()),
+                Some(NonZeroUsize::new(data.payload_len().into()).unwrap()),
                 RecvStatusFlags::empty()
             )
         );
 
         // This is the ack number that should be set/sent.
-        let expected_ack = t.remote_isn.wrapping_add(data.payload_len() as u32 + 1);
+        let expected_ack = t.remote_isn.wrapping_add(u32::from(data.payload_len()) + 1);
 
         // Check that internal state gets updated properly.
         assert_eq!(c.ack_to_send.0, expected_ack);
@@ -1493,7 +1493,7 @@ pub(crate) mod tests {
         assert!(t.write_next_segment(&mut c, None).unwrap().is_none());
 
         {
-            let payload_len = data.payload_len() as u32;
+            let payload_len = u32::from(data.payload_len());
 
             // Assuming no one changed the code, the local window size of the connection was 10000,
             // so we should be able to successfully receive 9 more segments with 1000 byte payloads.
@@ -1504,7 +1504,7 @@ pub(crate) mod tests {
                 assert_eq!(
                     t.receive_segment(&mut c, &data).unwrap(),
                     (
-                        Some(NonZeroUsize::new(data.payload_len()).unwrap()),
+                        Some(NonZeroUsize::new(data.payload_len().into()).unwrap()),
                         RecvStatusFlags::empty()
                     )
                 );
@@ -1550,7 +1550,7 @@ pub(crate) mod tests {
         // The mss is 1100, and the remote window is 11000, so we can send 10 data packets.
         let max = 10;
         let remote_isn = t.remote_isn;
-        let mss = u32::from(t.mss);
+        let mss = t.mss;
 
         let (payload_buf, mut response_seq) = payload_src.unwrap();
         let mut payload_offset = 0;
@@ -1561,22 +1561,25 @@ pub(crate) mod tests {
                 .unwrap_or_else(|_| panic!("{}", i))
                 .unwrap_or_else(|| panic!("{}", i));
 
-            payload_offset += s.payload_len();
-            response_seq += Wrapping(s.payload_len() as u32);
+            payload_offset += usize::from(s.payload_len());
+            response_seq += Wrapping(u32::from(s.payload_len()));
 
             // Again, the 1 accounts for the sequence number taken up by the SYN.
-            assert_eq!(s.sequence_number(), conn_isn.wrapping_add(1 + i * mss));
+            assert_eq!(
+                s.sequence_number(),
+                conn_isn.wrapping_add(1 + i * u32::from(mss)),
+            );
             assert_eq!(s.ack_number(), remote_isn.wrapping_add(1));
             assert_eq!(s.flags_after_ns(), TcpFlags::ACK);
-            assert_eq!(s.payload_len() as u32, mss);
+            assert_eq!(s.payload_len(), mss);
         }
 
         // No more new data can be sent until the window advances, even though data_buf
         // contains 20_000 bytes.
         assert!(t.write_next_segment(&mut c, payload_src).unwrap().is_none());
 
         // Let's ACK the first segment previously sent.
-        ctrl.set_ack_number(conn_isn.wrapping_add(1 + mss))
+        ctrl.set_ack_number(conn_isn.wrapping_add(1 + u32::from(mss)))
             .set_flags_after_ns(TcpFlags::ACK);
         assert_eq!(
             t.receive_segment(&mut c, &ctrl).unwrap(),
@@ -1586,8 +1589,11 @@ pub(crate) mod tests {
         // We should be able to send one more segment now.
         {
             let s = t.write_next_segment(&mut c, payload_src).unwrap().unwrap();
-            assert_eq!(s.sequence_number(), conn_isn.wrapping_add(1 + max * mss));
-            assert_eq!(s.payload_len(), mss as usize);
+            assert_eq!(
+                s.sequence_number(),
+                conn_isn.wrapping_add(1 + max * u32::from(mss)),
+            );
+            assert_eq!(s.payload_len(), mss);
         }
         assert!(t.write_next_segment(&mut c, payload_src).unwrap().is_none());
 
@@ -1604,7 +1610,7 @@ pub(crate) mod tests {
         {
             let s = t.write_next_segment(&mut c, payload_src).unwrap().unwrap();
             assert_eq!(s.sequence_number(), ctrl.ack_number());
-            assert_eq!(s.payload_len(), mss as usize);
+            assert_eq!(s.payload_len(), mss);
         }
         assert!(t.write_next_segment(&mut c, payload_src).unwrap().is_none());
 
@@ -1613,7 +1619,7 @@ pub(crate) mod tests {
         {
             let s = t.write_next_segment(&mut c, payload_src).unwrap().unwrap();
             assert_eq!(s.sequence_number(), ctrl.ack_number());
-            assert_eq!(s.payload_len(), mss as usize);
+            assert_eq!(s.payload_len(), mss);
         }
         assert!(t.write_next_segment(&mut c, payload_src).unwrap().is_none());
 
@@ -1626,7 +1632,7 @@ pub(crate) mod tests {
         {
             let s = t.write_next_segment(&mut c, payload_src).unwrap().unwrap();
             assert_eq!(s.sequence_number(), ctrl.ack_number());
-            assert_eq!(s.payload_len(), mss as usize);
+            assert_eq!(s.payload_len(), mss);
         }
         assert!(t.write_next_segment(&mut c, payload_src).unwrap().is_none());
 

src/vmm/src/dumbo/tcp/endpoint.rs

@@ -490,7 +490,7 @@ mod tests {
             endpoint_first_not_sent = s
                 .inner()
                 .sequence_number()
-                .wrapping_add(s.inner().payload_len() as u32);
+                .wrapping_add(u32::from(s.inner().payload_len()));
         }
 
         // Cool, now let's check that even though receive_buf is limited to some value, we can
@@ -535,7 +535,7 @@ mod tests {
                 assert!(response.contains("200"));
 
                 endpoint_first_not_sent =
-                    endpoint_first_not_sent.wrapping_add(s.inner().payload_len() as u32);
+                    endpoint_first_not_sent.wrapping_add(u32::from(s.inner().payload_len()));
             }
         }
 

src/vmm/src/dumbo/tcp/handler.rs

@@ -544,7 +544,7 @@ mod tests {
             (p.header_len(), p.len())
         };
 
-        TcpSegment::from_bytes(&mut buf[segment_start..segment_end], None).unwrap()
+        TcpSegment::from_bytes(&mut buf[segment_start.into()..segment_end], None).unwrap()
     }
 
     // Calls write_next_packet until either an error occurs, or there's nothing left to send.