Verify if data was copied without errors

Author: gblach

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "imge"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 description = "Write disk images to physical drive or vice versa."
 readme = "README.md"
@@ -15,6 +15,7 @@ crossterm = "0.28"
 derivative = "2.2"
 drives = "0.6"
 libarchive3-sys = "0.1"
+libc = "0.2"
 mime = "0.3"
 mime_guess = "2.0"
 num-format = { version = "0.4", features = ["with-system-locale"] }

Cargo.toml

@@ -4,14 +4,18 @@
 
 use libarchive3_sys::ffi::*;
 use mime::Mime;
+use std::alloc::{alloc, Layout};
 use std::ffi::{c_void, CString, OsString};
-use std::fs::File;
-use std::io;
+use std::fs::{File, OpenOptions};
 use std::io::prelude::*;
+use std::io::{self, Read};
 use std::os::unix::ffi::OsStrExt;
+use std::os::unix::fs::OpenOptionsExt;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
+const BLOCK_SIZE: usize = 1024 * 1024;
+
 pub struct Drive {
 	pub name: OsString,
 	pub model: String,
@@ -52,8 +56,8 @@ pub fn list(all_drives: bool) -> Vec<Drive> {
 
 #[derive(Default)]
 pub struct Progress {
-	pub copied: u64,
 	pub size: u64,
+	pub done: u64,
 	pub secs: u64,
 	pub finished: bool,
 }
@@ -63,7 +67,7 @@ impl Progress {
 		if self.size == 0 {
 			0.0
 		} else {
-			self.copied as f64 / self.size as f64
+			self.done as f64 / self.size as f64
 		}
 	}
 }
@@ -73,90 +77,108 @@ pub struct Path {
 	pub size: Option<u64>,
 }
 
-pub fn copy(src: &Path, dest: &Path, from_drive: bool, image_mime_type: Mime,
-	progress_mutex: &Arc<Mutex<Progress>>) -> io::Result<()> {
+fn libarchive_open_for_reading(path: &Path)
+	-> io::Result<(*mut Struct_archive, *mut Struct_archive_entry)> {
 
-	if !from_drive {
-		if let (Some(ssize), Some(dsize)) = (src.size, dest.size) {
-			if ssize > dsize {
-				return Err(io::Error::other("File too large (os error 27)"));
-			}
+	let filename = CString::new(path.path.as_bytes()).unwrap();
+
+	unsafe {
+		let a = archive_read_new();
+		archive_read_support_filter_all(a);
+		archive_read_support_format_raw(a);
+
+		let rc = archive_read_open_filename(a, filename.as_ptr(), BLOCK_SIZE);
+		if rc != ARCHIVE_OK {
+			return Err(io::Error::other("Cannot open file for reading"));
+		}
+
+		let ae = archive_entry_new2(a);
+		let ae_ptr = ae as *mut *mut Struct_archive_entry;
+		let rc = archive_read_next_header(a, ae_ptr);
+		if rc != ARCHIVE_OK {
+			return Err(io::Error::other("Cannot read file header"));
 		}
+
+		Ok((a, ae))
 	}
+}
 
-	let mut srcfile = File::open(&src.path)?;
+fn libarchive_open_for_writing(path: &Path, image_mime_type: Mime)
+	-> io::Result<(*mut Struct_archive, *mut Struct_archive_entry)> {
 
-	let a = unsafe {
-		match from_drive {
-			false => {
-				let a = archive_read_new();
-				archive_read_support_filter_all(a);
-				archive_read_support_format_raw(a);
-				a
-			},
-			true => {
-				let a = archive_write_new();
-				let filter = match image_mime_type.essence_str() {
-					"application/gzip" => 1,
-					"application/x-bzip2" => 2,
-					"application/x-xz" => 6,
-					"application/zstd" => 14,
-					_ => 0,
-				};
-				archive_write_add_filter(a, filter);
-				archive_write_set_format(a, 0x90000); // RAW
-				a
-			},
-		}
-	};
+	let filename = CString::new(path.path.as_bytes()).unwrap();
 
-	let ae = if !from_drive {
-		unsafe {
-			let srcfilename = CString::new(src.path.as_bytes()).unwrap();
-			let rc = archive_read_open_filename(a, srcfilename.as_ptr(), 1024 * 1024);
-			if rc != ARCHIVE_OK {
-				return Err(io::Error::other("Cannot open file for reading"));
-			}
+	unsafe {
+		let a = archive_write_new();
+		let filter = match image_mime_type.essence_str() {
+			"application/gzip" => 1,
+			"application/x-bzip2" => 2,
+			"application/x-xz" => 6,
+			"application/zstd" => 14,
+			_ => 0,
+		};
+		archive_write_add_filter(a, filter);
+		archive_write_set_format(a, 0x90000); // RAW
 
-			let ae = archive_entry_new2(a);
-			let ae_ptr = ae as *mut *mut Struct_archive_entry;
-			let rc = archive_read_next_header(a, ae_ptr);
-			if rc != ARCHIVE_OK {
-				return Err(io::Error::other("Cannot read file header"));
-			}
-			ae
+		let rc = archive_write_open_filename(a, filename.as_ptr());
+		if rc != ARCHIVE_OK {
+			return Err(io::Error::other("Cannot open file for writing"));
 		}
-	} else {
-		unsafe {
-			let destfilename = CString::new(dest.path.as_bytes()).unwrap();
-			let rc = archive_write_open_filename(a, destfilename.as_ptr());
-			if rc != ARCHIVE_OK {
-				return Err(io::Error::other("Cannot open file for writing"));
-			}
 
-			let ae = archive_entry_new2(a);
-			archive_entry_set_filetype(ae, AE_IFREG);
-			let rc = archive_write_header(a, ae);
-			if rc != ARCHIVE_OK {
-				return Err(io::Error::other("Cannot write file header"));
-			}
-			ae
+		let ae = archive_entry_new2(a);
+		archive_entry_set_filetype(ae, AE_IFREG);
+		let rc = archive_write_header(a, ae);
+		if rc != ARCHIVE_OK {
+			return Err(io::Error::other("Cannot write file header"));
+		}
+
+		Ok((a, ae))
+	}
+}
+
+fn libarchive_close_for_reading(a: *mut Struct_archive) {
+	unsafe {
+		archive_read_close(a);
+		archive_read_free(a);
+	}
+}
+
+fn libarchive_close_for_writing(a: *mut Struct_archive, ae: *mut Struct_archive_entry) {
+	unsafe {
+		archive_entry_free(ae);
+		archive_write_close(a);
+		archive_write_free(a);
+	}
+}
+
+pub fn copy(src: &Path, dest: &Path, from_drive: bool, image_mime_type: Mime,
+	progress_mutex: &Arc<Mutex<Progress>>) -> io::Result<()> {
+
+	if let (Some(ssize), Some(dsize)) = (src.size, dest.size) {
+		if !from_drive && ssize > dsize {
+			return Err(io::Error::other("File too large (os error 27)"));
 		}
+	}
+
+	let mut srcfile = File::open(&src.path)?;
+	let mut destfile = OpenOptions::new()
+		.create(true).write(true).truncate(true)
+		.custom_flags(libc::O_DSYNC).open(&dest.path)?;
+
+	let (a, ae) = match from_drive {
+		false => libarchive_open_for_reading(&src)?,
+		true => libarchive_open_for_writing(&dest, image_mime_type.clone())?,
 	};
 
-	let mut destfile = File::create(&dest.path)?;
-	let mut buffer = [0; 1024 * 1024];
+	let mut buffer = [0; BLOCK_SIZE];
 	let buffer_ptr = buffer.as_mut_ptr() as *mut c_void;
-	let timer = Instant::now();
 
-	let mut progress = progress_mutex.lock().unwrap();
-	progress.size = src.size.unwrap_or_default();
-	drop(progress);
+	let timer = Instant::now();
 
 	loop {
 		let len = match from_drive {
 			false => unsafe {
-				archive_read_data(a, buffer_ptr, 1024 * 1024)
+				archive_read_data(a, buffer_ptr, BLOCK_SIZE)
 			},
 			true => srcfile.read(&mut buffer)? as isize,
 		};
@@ -170,26 +192,78 @@ pub fn copy(src: &Path, dest: &Path, from_drive: bool, image_mime_type: Mime,
 			}
 		} else {
 			destfile.write_all(&buffer[..(len as usize)])?;
-			destfile.sync_data()?;
 		}
 
 		let mut progress = progress_mutex.lock().unwrap();
-		progress.copied += len as u64;
+		progress.done += len as u64;
 	}
 
-	unsafe {
-		if !from_drive {
-			archive_read_close(a);
-			archive_read_free(a);
-		} else {
-			archive_entry_free(ae);
-			archive_write_close(a);
-			archive_write_free(a);
+	match from_drive {
+		false => libarchive_close_for_reading(a),
+		true => libarchive_close_for_writing(a, ae),
+	};
+
+	let mut progress = progress_mutex.lock().unwrap();
+	progress.secs = timer.elapsed().as_secs();
+	progress.finished = true;
+
+	Ok(())
+}
+
+pub fn verify(src: &Path, dest: &Path, from_drive: bool,
+	progress_mutex: &Arc<Mutex<Progress>>) -> io::Result<()> {
+
+	let mut srcfile = File::open(&src.path)?;
+	let mut destfile = OpenOptions::new().read(true)
+		.custom_flags(libc::O_DIRECT).open(&dest.path)?;
+
+	let (a, _ae) = match from_drive {
+		false => libarchive_open_for_reading(&src)?,
+		true => libarchive_open_for_reading(&dest)?,
+	};
+
+
+	let mut srcbuffer = [0; BLOCK_SIZE];
+	let srcbuffer_ptr = srcbuffer.as_mut_ptr() as *mut c_void;
+	let destbuffer_ptr = unsafe {
+		alloc(Layout::from_size_align(BLOCK_SIZE, BLOCK_SIZE).unwrap())
+	};
+	let mut destbuffer = unsafe {
+		std::slice::from_raw_parts_mut(destbuffer_ptr, BLOCK_SIZE)
+	};
+
+	let timer = Instant::now();
+
+	loop {
+		let len = match from_drive {
+			false => unsafe {
+				archive_read_data(a, srcbuffer_ptr, BLOCK_SIZE)
+			},
+			true => srcfile.read(&mut srcbuffer)? as isize,
+		};
+		if len <= 0 {
+			break;
 		}
+
+		match from_drive {
+			false => destfile.read(&mut destbuffer)? as isize,
+			true => unsafe {
+				archive_read_data(a, destbuffer_ptr as *mut c_void, BLOCK_SIZE)
+			},
+		};
+
+		if &srcbuffer[..len as usize] != &destbuffer[..len as usize] {
+			return Err(io::Error::other("Verification failed"));
+		}
+
+		let mut progress = progress_mutex.lock().unwrap();
+		progress.done += len as u64;
 	}
 
+	libarchive_close_for_reading(a);
+
 	let mut progress = progress_mutex.lock().unwrap();
-	progress.secs = timer.elapsed().as_secs();
+	progress.secs += timer.elapsed().as_secs();
 	progress.finished = true;
 
 	Ok(())

src/imge.rs

@@ -28,6 +28,10 @@ struct Args {
 	#[argh(switch, short='f')]
 	from_drive: bool,
 
+	/// verify if data was copied correctly
+	#[argh(switch, short='v')]
+	verify: bool,
+
 	/// path to image
 	#[argh(positional)]
 	image: OsString,