use u64 to represent file size

This increases the maximum supported file size (previously limited to 4GB)
and avoids potential issues with u32 to u64 conversions, which are no longer
needed.

Signed-off-by: onur-ozkan <work@onurozkan.dev>

Author: onur-ozkan

src/tools/remote-test-client/src/main.rs

@@ -300,18 +300,18 @@ fn run(support_lib_count: usize, exe: String, all_args: Vec<String>) {
 
     // Ok now it's time to read all the output. We're receiving "frames"
     // representing stdout/stderr, so we decode all that here.
-    let mut header = [0; 5];
+    let mut header = [0; 9];
     let mut stderr_done = false;
     let mut stdout_done = false;
     let mut client = t!(client.into_inner());
     let mut stdout = io::stdout();
     let mut stderr = io::stderr();
     while !stdout_done || !stderr_done {
         t!(client.read_exact(&mut header));
-        let amt = ((header[1] as u64) << 24)
-            | ((header[2] as u64) << 16)
-            | ((header[3] as u64) << 8)
-            | ((header[4] as u64) << 0);
+        let mut amt = 0u64;
+        for (i, &byte) in header[1..=8].iter().enumerate() {
+            amt |= (byte as u64) << (56 - 8 * i);
+        }
         if header[0] == 0 {
             if amt == 0 {
                 stdout_done = true;
@@ -349,7 +349,8 @@ fn send(path: &Path, dst: &mut dyn Write) {
     t!(dst.write_all(&[0]));
     let mut file = t!(File::open(&path));
     let amt = t!(file.metadata()).len();
-    t!(dst.write_all(&[(amt >> 24) as u8, (amt >> 16) as u8, (amt >> 8) as u8, (amt >> 0) as u8,]));
+
+    t!(dst.write_all(&amt.to_be_bytes()));
     t!(io::copy(&mut file, dst));
 }
 

src/tools/remote-test-server/src/main.rs

@@ -347,7 +347,7 @@ fn recv<B: BufRead>(dir: &Path, io: &mut B) -> PathBuf {
     // the filesystem limits.
     let len = cmp::min(filename.len() - 1, 50);
     let dst = dir.join(t!(str::from_utf8(&filename[..len])));
-    let amt = read_u32(io) as u64;
+    let amt = read_u64(io);
     t!(io::copy(&mut io.take(amt), &mut t!(File::create(&dst))));
     set_permissions(&dst);
     dst
@@ -365,7 +365,7 @@ fn my_copy(src: &mut dyn Read, which: u8, dst: &Mutex<dyn Write>) {
     loop {
         let n = t!(src.read(&mut b));
         let mut dst = dst.lock().unwrap();
-        t!(dst.write_all(&create_header(which, n as u32)));
+        t!(dst.write_all(&create_header(which, n as u64)));
         if n > 0 {
             t!(dst.write_all(&b[..n]));
         } else {
@@ -377,21 +377,21 @@ fn my_copy(src: &mut dyn Read, which: u8, dst: &Mutex<dyn Write>) {
 fn batch_copy(buf: &[u8], which: u8, dst: &Mutex<dyn Write>) {
     let n = buf.len();
     let mut dst = dst.lock().unwrap();
-    t!(dst.write_all(&create_header(which, n as u32)));
+    t!(dst.write_all(&create_header(which, n as u64)));
     if n > 0 {
         t!(dst.write_all(buf));
         // Marking buf finished
         t!(dst.write_all(&[which, 0, 0, 0, 0,]));
     }
 }
 
-const fn create_header(which: u8, n: u32) -> [u8; 5] {
+const fn create_header(which: u8, n: u64) -> [u8; 9] {
     let bytes = n.to_be_bytes();
-    [which, bytes[0], bytes[1], bytes[2], bytes[3]]
+    [which, bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]]
 }
 
-fn read_u32(r: &mut dyn Read) -> u32 {
-    let mut len = [0; 4];
+fn read_u64(r: &mut dyn Read) -> u64 {
+    let mut len = [0; 8];
     t!(r.read_exact(&mut len));
-    u32::from_be_bytes(len)
+    u64::from_be_bytes(len)
 }