pub fn extract_7z(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a 7Z archive.
+input_path - The path to the 7Z file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_7z(Path::new("src/test_data/test.7z"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_bz2(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a BZ2 (bzip2) compressed archive.
+input_path - The path to the BZ2 compressed file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_bz2(Path::new("src/test_data/test.bz2"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_gz(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a GZ (gzip) compressed archive.
+input_path - The path to the GZ compressed file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_gz(Path::new("src/test_data/test.gz"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_lzma(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from an LZMA compressed archive.
+input_path - The path to the LZMA compressed file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_lzma(Path::new("src/test_data/test.lzma"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_rar(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Box<dyn Error>>Extracts files from a RAR archive.
+input_path - The path to the RAR file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_rar(Path::new("src/test_data/test.rar"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_tar(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a TAR archive.
+input_path - The path to the TAR file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_tar(Path::new("src/test_data/test.tar"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_tbz2(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a TBZ2 (tar.bz2) compressed archive.
+input_path - The path to the TBZ2 compressed file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_tbz2(Path::new("src/test_data/test.tbz2"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_tgz(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a TGZ (tar.gz) compressed archive.
+input_path - The path to the TGZ compressed file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_tgz(Path::new("src/test_data/test.tgz"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_txz(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a TXZ (tar.xz) compressed archive.
+input_path - The path to the TXZ compressed file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_txz(Path::new("src/test_data/test.txz"), Path::new("output_directory"));
+assert!(result.is_ok());pub fn extract_zip(
+ input_path: &Path,
+ output_directory: &Path
+) -> Result<(), Error>Extracts files from a ZIP archive.
+input_path - The path to the ZIP file to extract.output_directory - The destination directory for extracted files.Returns Ok(()) on success, or an Error if extraction fails.
use std::path::Path;
+let result = extract_zip(Path::new("src/test_data/test.zip"), Path::new("output_directory"));
+assert!(result.is_ok());1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +
use std::{fs::{self, File}, error::Error, io::{self, ErrorKind, Write, Read}, path::Path,};
+use lzma::reader::LzmaReader;
+use flate2::read::GzDecoder;
+use bzip2::read::BzDecoder;
+use unrar::Archive;
+
+/// Extracts files from a ZIP archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the ZIP file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_zip(Path::new("src/test_data/test.zip"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_zip(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let file = fs::File::open(input_path)?;
+ let mut archive = zip::ZipArchive::new(file)?;
+ for i in 0..archive.len() {
+ let mut file = archive.by_index(i)?;
+ let outpath = match file.enclosed_name() {
+ Some(path) => path.to_owned(),
+ None => continue,
+ };
+ let full_outpath = output_directory.join(&outpath);
+ {
+ let comment = file.comment();
+ if !comment.is_empty() {
+ println!("File {} comment: {}", i, comment);
+ }
+ }
+ if (*file.name()).ends_with('/') {
+ fs::create_dir_all(&full_outpath).unwrap();
+ } else {
+ if let Some(p) = full_outpath.parent() {
+ if !p.exists() {
+ fs::create_dir_all(p).unwrap();
+ }
+ }
+ let mut outfile = fs::File::create(&full_outpath).unwrap();
+ io::copy(&mut file, &mut outfile).unwrap();
+ }
+ // Get and Set permissions
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+
+ if let Some(mode) = file.unix_mode() {
+ fs::set_permissions(&full_outpath, fs::Permissions::from_mode(mode)).unwrap();
+ }
+ }
+ }
+
+ Ok(())
+}
+
+/// Extracts files from a RAR archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the RAR file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_rar(Path::new("src/test_data/test.rar"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_rar(input_path: &Path, output_directory: &Path) -> Result<(), Box<dyn Error>> {
+ let mut archive = Archive::new(input_path)
+ .open_for_processing()
+ .unwrap();
+ while let Some(header) = archive.read_header()? {
+ let output_path = output_directory.join(&header.entry().filename);
+ archive = if header.entry().is_file() {
+ header.extract_to(&output_path)?
+ } else {
+ header.skip()?
+ };
+ }
+ Ok(())
+}
+
+/// Extracts files from a TAR archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the TAR file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_tar(Path::new("src/test_data/test.tar"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_tar(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let tar_file = fs::File::open(input_path)?;
+ let mut a = tar::Archive::new(tar_file);
+
+ for i in a.entries()? {
+ let mut i = i?;
+ let entry_path = i.header().path()?;
+ let full_path = output_directory.join(entry_path);
+
+ if i.header().entry_type().is_dir() {
+ fs::create_dir_all(&full_path)?;
+ } else {
+ fs::create_dir_all(&full_path.parent().unwrap())?;
+
+ let mut file = fs::File::create(&full_path)?;
+ io::copy(&mut i, &mut file)?;
+ }
+ }
+
+ Ok(())
+}
+
+/// Extracts files from an LZMA compressed archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the LZMA compressed file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_lzma(Path::new("src/test_data/test.lzma"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_lzma(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let input_file = File::open(input_path)?;
+ let mut decompressor = LzmaReader::new_decompressor(input_file)
+ .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+ let output_file_path = output_directory.join(input_path.file_stem().unwrap());
+ let mut output_file = File::create(&output_file_path)?;
+ io::copy(&mut decompressor, &mut output_file)?;
+ Ok(())
+}
+
+/// Extracts files from a GZ (gzip) compressed archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the GZ compressed file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_gz(Path::new("src/test_data/test.gz"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_gz(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let input_file = File::open(input_path)?;
+ let mut decompressor = GzDecoder::new(input_file);
+ let output_file_path = output_directory.join(input_path.file_stem().unwrap());
+ let mut output_file = File::create(&output_file_path)?;
+ match io::copy(&mut decompressor, &mut output_file) {
+ Ok(_) => Ok(()),
+ Err(err) => Err(io::Error::new(ErrorKind::Other, err.to_string())),
+ }
+}
+
+/// Extracts files from a BZ2 (bzip2) compressed archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the BZ2 compressed file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_bz2(Path::new("src/test_data/test.bz2"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_bz2(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let input_file = File::open(input_path)?;
+ let bz2_reader = BzDecoder::new(input_file);
+ let output_file_path = output_directory.join(input_path.file_stem().unwrap());
+ let mut output_file = File::create(&output_file_path)?;
+ let mut buffer = Vec::new();
+ let mut decompressor = io::BufReader::new(bz2_reader);
+ loop {
+ let bytes_read = decompressor.read_to_end(&mut buffer)?;
+ if bytes_read == 0 {
+ break; // End of file
+ }
+ output_file.write_all(&buffer[..bytes_read])?;
+ buffer.clear();
+ }
+
+ Ok(())
+}
+
+/// Extracts files from a 7Z archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the 7Z file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_7z(Path::new("src/test_data/test.7z"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_7z(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ sevenz_rust::decompress_file(input_path, output_directory).expect("complete");
+ Ok(())
+}
+
+/// Extracts files from a TBZ2 (tar.bz2) compressed archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the TBZ2 compressed file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_tbz2(Path::new("src/test_data/test.tbz2"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_tbz2(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let input_file = File::open(input_path)?;
+ let bz2_reader = BzDecoder::new(input_file);
+ let mut archive = tar::Archive::new(bz2_reader);
+ for entry in archive.entries()? {
+ let mut entry = entry?;
+ let entry_path = entry.path()?;
+ let full_path = output_directory.join(entry_path);
+ if entry.header().entry_type().is_dir() {
+ fs::create_dir_all(&full_path)?;
+ } else {
+ fs::create_dir_all(&full_path.parent().unwrap())?;
+
+ let mut file = fs::File::create(&full_path)?;
+ io::copy(&mut entry, &mut file)?;
+ }
+ }
+ Ok(())
+}
+
+
+/// Extracts files from a TGZ (tar.gz) compressed archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the TGZ compressed file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_tgz(Path::new("src/test_data/test.tgz"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_tgz(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let input_file = File::open(input_path)?;
+ let mut decompressor = GzDecoder::new(input_file);
+ let mut archive = tar::Archive::new(&mut decompressor);
+ for entry in archive.entries()? {
+ let mut entry = entry?;
+ let entry_path = entry.path()?;
+ let full_path = output_directory.join(entry_path);
+ if entry.header().entry_type().is_dir() {
+ fs::create_dir_all(&full_path)?;
+ } else {
+ fs::create_dir_all(&full_path.parent().unwrap())?;
+ let mut file = fs::File::create(&full_path)?;
+ io::copy(&mut entry, &mut file)?;
+ }
+ }
+ Ok(())
+}
+
+/// Extracts files from a TXZ (tar.xz) compressed archive.
+///
+/// # Arguments
+///
+/// * `input_path` - The path to the TXZ compressed file to extract.
+/// * `output_directory` - The destination directory for extracted files.
+///
+/// # Returns
+///
+/// Returns `Ok(())` on success, or an `Error` if extraction fails.
+///
+/// # Examples
+///
+/// ```
+/// use std::path::Path;
+/// let result = extract_txz(Path::new("src/test_data/test.txz"), Path::new("output_directory"));
+/// assert!(result.is_ok());
+/// ```
+pub fn extract_txz(input_path: &Path, output_directory: &Path) -> Result<(), io::Error> {
+ let input_file = File::open(input_path)?;
+ let mut decompressor = LzmaReader::new_decompressor(input_file)
+ .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+ let mut archive = tar::Archive::new(&mut decompressor);
+ for entry in archive.entries()? {
+ let mut entry = entry?;
+ let entry_path = entry.path()?;
+ let full_path = output_directory.join(entry_path);
+ if entry.header().entry_type().is_dir() {
+ fs::create_dir_all(&full_path)?;
+ } else {
+ fs::create_dir_all(&full_path.parent().unwrap())?;
+ let mut file = fs::File::create(&full_path)?;
+ io::copy(&mut entry, &mut file)?;
+ }
+ }
+ Ok(())
+}
+1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +
+pub mod extractors;
+
+#[cfg(test)]
+mod tests {
+ use std::{io,os::unix::fs::PermissionsExt};
+ use serial_test::serial;
+ use super::*;
+ use std::fs;
+ use std::path::PathBuf;
+ use std::path::Path;
+ use std::io::Read;
+use extractors::{
+ extract_zip,
+ extract_rar,
+ extract_tar,
+ extract_tbz2,
+ extract_tgz,
+ extract_txz,
+ extract_7z,
+ // extract_arj,
+ // extract_cab,
+ // extract_chm,
+ // extract_deb,
+ // extract_dmg,
+ // extract_iso,
+ // extract_lzh,
+ // extract_msi,
+ // extract_rpm,
+ // extract_udf,
+ // extract_wim,
+ // extract_xar,
+ // extract_exe
+};
+
+#[test]
+#[serial]
+fn test_extract_zip() {
+ let input_path = Path::new("src/test_data/test.zip");
+ let output_directory = create_temp_dir();
+
+ // Extract the zip file
+ let result = extract_zip(input_path, &output_directory);
+ assert!(result.is_ok());
+
+ // Check checksums and assert equality
+ let checksum_01 = verify_checksum("test_dir/checksum_01", "test_dir/testfile_01").unwrap();
+ assert_eq!(checksum_01, true);
+
+ let checksum_02 = verify_checksum("test_dir/checksum_02", "test_dir/testfile_02").unwrap();
+ assert_eq!(checksum_02, true);
+
+ let checksum_03 = verify_checksum("test_dir/checksum_03", "test_dir/testfile_03").unwrap();
+ assert_eq!(checksum_03, true);
+
+ // Check Permissions match original 644 compression perms
+ let tf1_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf1_perms.is_ok());
+
+ let tf2_perms = check_permissions("test_dir/testfile_02",644);
+ assert!(tf2_perms.is_ok());
+
+ let tf3_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf3_perms.is_ok());
+
+ let csum1_perms = check_permissions("test_dir/checksum_01",644);
+ assert!(csum1_perms.is_ok());
+
+ let csum2_perms = check_permissions("test_dir/checksum_02",644);
+ assert!(csum2_perms.is_ok());
+
+ let csum3_perms = check_permissions("test_dir/checksum_03",644);
+ assert!(csum3_perms.is_ok());
+
+ // Delete the test directory at the end of the test
+ if let Err(err) = fs::remove_dir_all(&output_directory) {
+ eprintln!("Failed to delete test directory: {:?}", err);
+ }
+}
+
+#[test]
+#[serial]
+fn test_extract_rar() {
+ let input_path = Path::new("src/test_data/test.rar");
+ let output_directory = create_temp_dir();
+ let result = extract_rar(input_path, &output_directory);
+ assert!(result.is_ok());
+
+ // Check checksums and assert equality
+ let checksum_01 = verify_checksum("test_dir/checksum_01", "test_dir/testfile_01").unwrap();
+ assert_eq!(checksum_01, true);
+
+ let checksum_02 = verify_checksum("test_dir/checksum_02", "test_dir/testfile_02").unwrap();
+ assert_eq!(checksum_02, true);
+
+ let checksum_03 = verify_checksum("test_dir/checksum_03", "test_dir/testfile_03").unwrap();
+ assert_eq!(checksum_03, true);
+
+ // Check Permissions match original 644 compression perms
+ let tf1_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf1_perms.is_ok());
+
+ let tf2_perms = check_permissions("test_dir/testfile_02",644);
+ assert!(tf2_perms.is_ok());
+
+ let tf3_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf3_perms.is_ok());
+
+ let csum1_perms = check_permissions("test_dir/checksum_01",644);
+ assert!(csum1_perms.is_ok());
+
+ let csum2_perms = check_permissions("test_dir/checksum_02",644);
+ assert!(csum2_perms.is_ok());
+
+ let csum3_perms = check_permissions("test_dir/checksum_03",644);
+ assert!(csum3_perms.is_ok());
+
+ // Delete the test directory at the end of the test
+ if let Err(err) = fs::remove_dir_all(&output_directory) {
+ eprintln!("Failed to delete test directory: {:?}", err);
+ }
+}
+
+#[test]
+#[serial]
+fn test_extract_tar() {
+ let input_path = Path::new("src/test_data/test.tar");
+ let output_directory = create_temp_dir();
+ let result = extract_tar(input_path, &output_directory);
+ assert!(result.is_ok());
+
+ // Check checksums and assert equality
+ let checksum_01 = verify_checksum("test_dir/checksum_01", "test_dir/testfile_01").unwrap();
+ assert_eq!(checksum_01, true);
+
+ let checksum_02 = verify_checksum("test_dir/checksum_02", "test_dir/testfile_02").unwrap();
+ assert_eq!(checksum_02, true);
+
+ let checksum_03 = verify_checksum("test_dir/checksum_03", "test_dir/testfile_03").unwrap();
+ assert_eq!(checksum_03, true);
+
+ // Check Permissions match original 644 compression perms
+ let tf1_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf1_perms.is_ok());
+
+ let tf2_perms = check_permissions("test_dir/testfile_02",644);
+ assert!(tf2_perms.is_ok());
+
+ let tf3_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf3_perms.is_ok());
+
+ let csum1_perms = check_permissions("test_dir/checksum_01",644);
+ assert!(csum1_perms.is_ok());
+
+ let csum2_perms = check_permissions("test_dir/checksum_02",644);
+ assert!(csum2_perms.is_ok());
+
+ let csum3_perms = check_permissions("test_dir/checksum_03",644);
+ assert!(csum3_perms.is_ok());
+
+ // Delete the test directory at the end of the test
+ if let Err(err) = fs::remove_dir_all(&output_directory) {
+ eprintln!("Failed to delete test directory: {:?}", err);
+ }
+}
+
+#[test]
+#[serial]
+fn test_extract_7z() {
+ let input_path = Path::new("src/test_data/test.7z");
+ let output_directory = create_temp_dir();
+ let result = extract_7z(input_path, &output_directory);
+ assert!(result.is_ok());
+
+ // Check checksums and assert equality
+ let checksum_01 = verify_checksum("test_dir/checksum_01", "test_dir/testfile_01").unwrap();
+ assert_eq!(checksum_01, true);
+
+ let checksum_02 = verify_checksum("test_dir/checksum_02", "test_dir/testfile_02").unwrap();
+ assert_eq!(checksum_02, true);
+
+ let checksum_03 = verify_checksum("test_dir/checksum_03", "test_dir/testfile_03").unwrap();
+ assert_eq!(checksum_03, true);
+
+ // Check Permissions match original 644 compression perms
+ let tf1_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf1_perms.is_ok());
+
+ let tf2_perms = check_permissions("test_dir/testfile_02",644);
+ assert!(tf2_perms.is_ok());
+
+ let tf3_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf3_perms.is_ok());
+
+ let csum1_perms = check_permissions("test_dir/checksum_01",644);
+ assert!(csum1_perms.is_ok());
+
+ let csum2_perms = check_permissions("test_dir/checksum_02",644);
+ assert!(csum2_perms.is_ok());
+
+ let csum3_perms = check_permissions("test_dir/checksum_03",644);
+ assert!(csum3_perms.is_ok());
+
+ // Delete the test directory at the end of the test
+ if let Err(err) = fs::remove_dir_all(&output_directory) {
+ eprintln!("Failed to delete test directory: {:?}", err);
+ }
+}
+
+#[test]
+#[serial]
+fn test_extract_tbz2() {
+ let input_path = Path::new("src/test_data/test.tbz2");
+ let output_directory = create_temp_dir();
+
+ let result = extract_tbz2(input_path, &output_directory);
+ assert!(result.is_ok());
+
+ // Check checksums and assert equality
+ let checksum_01 = verify_checksum("test_dir/checksum_01", "test_dir/testfile_01").unwrap();
+ assert_eq!(checksum_01, true);
+
+ let checksum_02 = verify_checksum("test_dir/checksum_02", "test_dir/testfile_02").unwrap();
+ assert_eq!(checksum_02, true);
+
+ let checksum_03 = verify_checksum("test_dir/checksum_03", "test_dir/testfile_03").unwrap();
+ assert_eq!(checksum_03, true);
+
+ // Check Permissions match original 644 compression perms
+ let tf1_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf1_perms.is_ok());
+
+ let tf2_perms = check_permissions("test_dir/testfile_02",644);
+ assert!(tf2_perms.is_ok());
+
+ let tf3_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf3_perms.is_ok());
+
+ let csum1_perms = check_permissions("test_dir/checksum_01",644);
+ assert!(csum1_perms.is_ok());
+
+ let csum2_perms = check_permissions("test_dir/checksum_02",644);
+ assert!(csum2_perms.is_ok());
+
+ let csum3_perms = check_permissions("test_dir/checksum_03",644);
+ assert!(csum3_perms.is_ok());
+
+ // Delete the test directory at the end of the test
+ if let Err(err) = fs::remove_dir_all(&output_directory) {
+ eprintln!("Failed to delete test directory: {:?}", err);
+ }
+}
+
+#[test]
+#[serial]
+fn test_extract_tgz() {
+ let input_path = Path::new("src/test_data/test.tgz");
+ let output_directory = create_temp_dir();
+ let result = extract_tgz(input_path, &output_directory);
+ assert!(result.is_ok());
+
+ // Check checksums and assert equality
+ let checksum_01 = verify_checksum("test_dir/checksum_01", "test_dir/testfile_01").unwrap();
+ assert_eq!(checksum_01, true);
+
+ let checksum_02 = verify_checksum("test_dir/checksum_02", "test_dir/testfile_02").unwrap();
+ assert_eq!(checksum_02, true);
+
+ let checksum_03 = verify_checksum("test_dir/checksum_03", "test_dir/testfile_03").unwrap();
+ assert_eq!(checksum_03, true);
+
+ // Check Permissions match original 644 compression perms
+ let tf1_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf1_perms.is_ok());
+
+ let tf2_perms = check_permissions("test_dir/testfile_02",644);
+ assert!(tf2_perms.is_ok());
+
+ let tf3_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf3_perms.is_ok());
+
+ let csum1_perms = check_permissions("test_dir/checksum_01",644);
+ assert!(csum1_perms.is_ok());
+
+ let csum2_perms = check_permissions("test_dir/checksum_02",644);
+ assert!(csum2_perms.is_ok());
+
+ let csum3_perms = check_permissions("test_dir/checksum_03",644);
+ assert!(csum3_perms.is_ok());
+
+ // Delete the test directory at the end of the test
+ if let Err(err) = fs::remove_dir_all(&output_directory) {
+ eprintln!("Failed to delete test directory: {:?}", err);
+ }
+}
+
+#[test]
+#[serial]
+fn test_extract_txz() {
+ let input_path = Path::new("src/test_data/test.txz");
+ let output_directory = create_temp_dir();
+ let result = extract_txz(input_path, &output_directory);
+ assert!(result.is_ok());
+
+ // Check checksums and assert equality
+ let checksum_01 = verify_checksum("test_dir/checksum_01", "test_dir/testfile_01").unwrap();
+ assert_eq!(checksum_01, true);
+
+ let checksum_02 = verify_checksum("test_dir/checksum_02", "test_dir/testfile_02").unwrap();
+ assert_eq!(checksum_02, true);
+
+ let checksum_03 = verify_checksum("test_dir/checksum_03", "test_dir/testfile_03").unwrap();
+ assert_eq!(checksum_03, true);
+
+ // Check Permissions match original 644 compression perms
+ let tf1_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf1_perms.is_ok());
+
+ let tf2_perms = check_permissions("test_dir/testfile_02",644);
+ assert!(tf2_perms.is_ok());
+
+ let tf3_perms = check_permissions("test_dir/testfile_01",644);
+ assert!(tf3_perms.is_ok());
+
+ let csum1_perms = check_permissions("test_dir/checksum_01",644);
+ assert!(csum1_perms.is_ok());
+
+ let csum2_perms = check_permissions("test_dir/checksum_02",644);
+ assert!(csum2_perms.is_ok());
+
+ let csum3_perms = check_permissions("test_dir/checksum_03",644);
+ assert!(csum3_perms.is_ok());
+
+ // Delete the test directory at the end of the test
+ if let Err(err) = fs::remove_dir_all(&output_directory) {
+ eprintln!("Failed to delete test directory: {:?}", err);
+ }
+}
+
+fn verify_checksum(checksum_path: &str, testfile_path: &str) -> Result<bool, std::io::Error> {
+ let mut checksum_file = fs::File::open(checksum_path).expect("Failed to open checksum file");
+ let mut checksum_data = String::new();
+ checksum_file
+ .read_to_string(&mut checksum_data)
+ .expect("Failed to read checksum data");
+ let mut checksum_data_uppercase = checksum_data.to_uppercase();
+
+ if checksum_data_uppercase.len() >= 2 {
+ checksum_data_uppercase.truncate(checksum_data_uppercase.len() - 1);
+ } else {
+ eprintln!("String is too short to remove characters");
+ }
+
+ let mut testfile = fs::File::open(testfile_path).expect("Failed to open test file");
+ let testfile_buffer = io::BufReader::new(&mut testfile);
+ let calculated_checksum = data_encoding::HEXUPPER.encode(sha256_digest(testfile_buffer)?.as_ref());
+ let tf_path = Path::new(testfile_path);
+ let mut checksum_with_filename = String::new(); // Initialize the variable
+ if let Some(testfile_name) = tf_path.file_name() {
+ if let Some(testfile_name_str) = testfile_name.to_str() {
+ checksum_with_filename = format!("{} {}", calculated_checksum, testfile_name_str.to_uppercase());
+ }
+ } else {
+ eprintln!("Invalid path or no file name found.");
+ }
+
+ Ok(checksum_with_filename == checksum_data_uppercase)
+}
+
+fn create_temp_dir() -> PathBuf {
+ // Specify the absolute path for the permanent directory
+ let temp_dir = Path::new("test_dir");
+
+ // Create the directory if it doesn't exist
+ if !temp_dir.exists() {
+ fs::create_dir_all(&temp_dir).expect("Failed to create temp directory");
+ }
+ temp_dir.to_path_buf()
+}
+
+fn sha256_digest<R: io::Read>(mut reader: R) -> Result<ring::digest::Digest, std::io::Error> {
+ let mut context = ring::digest::Context::new(&ring::digest::SHA256);
+ let mut buffer = [0; 1024];
+
+ loop {
+ let count = reader.read(&mut buffer)?;
+ if count == 0 {
+ break;
+ }
+ context.update(&buffer[..count]);
+ }
+
+ Ok(context.finish())
+}
+fn mode_to_chmod(mode: u32) -> u32 {
+ let mut flags:u32 = 0;
+
+ // Owner permissions
+ if (mode & 0o400) != 0 { flags = flags+400 } else { flags = flags+0 };
+ if (mode & 0o200) != 0 { flags = flags+200 } else { flags = flags+0 };
+ if (mode & 0o100) != 0 { flags = flags+100 } else { flags = flags+0 };
+
+ // Group permissions
+ if (mode & 0o40) != 0 { flags = flags+40 } else { flags = flags+0 };
+ if (mode & 0o20) != 0 { flags = flags+20 } else { flags = flags+0 };
+ if (mode & 0o10) != 0 { flags = flags+10 } else { flags = flags+0 };
+
+ // Others permissions
+ if (mode & 0o4) != 0 { flags = flags+4 } else { flags = flags+0 };
+ if (mode & 0o2) != 0 { flags = flags+2 } else { flags = flags+0 };
+ if (mode & 0o1) != 0 { flags = flags+1 } else { flags = flags+0 };
+
+ flags
+}
+fn check_permissions(filepath: &str, perms: u32) -> Result<bool, std::io::Error> {
+ let file = fs::File::open(filepath)?;
+ let metadata = file.metadata()?;
+ let permissions = metadata.permissions();
+ let mode = permissions.mode();
+ let chmod = mode_to_chmod(mode);
+ Ok(chmod == perms)
+}
+}
+fn:) to \
+ restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \
+ enum, trait, type, macro, \
+ and const.","Search functions by type signature (e.g., vec -> usize or \
+ -> vec or String, enum:Cow -> bool)","You can look for items with an exact name by putting double quotes around \
+ your request: \"string\"","Look for items inside another one by searching for a path: vec::Vec",].map(x=>""+x+"
").join("");const div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="${value}`}else{error[index]=value}});output+=`