jessikitty/drop
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

match result code before extracting an error

Browse Source
This commit is contained in:
Jamie Winsor
2016-03-21 13:22:30 -07:00
parent f7cc72e071
commit a2e51c7f8b
2 changed files with 124 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/libarchive/src/reader.rs
+58 -107
View File
@@ -107,7 +107,7 @@ impl FileReader {
let c_file = CString::new(file.as_ref().to_string_lossy().as_bytes()).unwrap();
unsafe {
match ffi::archive_read_open_filename(builder.handle(), c_file.as_ptr(), BLOCK_SIZE) {
0 => {
ffi::ARCHIVE_OK => {
builder.consume();
Ok(Self::new(builder.handle()))
}
@@ -155,7 +155,7 @@ impl StreamReader {
None,
Some(stream_read_callback),
None) {
0 => {
ffi::ARCHIVE_OK => {
let reader = StreamReader {
handle: builder.handle(),
entry: ReaderEntry::default(),
@@ -200,84 +200,63 @@ impl Builder {
}
pub fn support_compression(&mut self, compression: ReadCompression) -> ArchiveResult<()> {
match compression {
let result = match compression {
ReadCompression::All => unsafe {
ffi::archive_read_support_compression_all(self.handle);
ffi::archive_read_support_compression_all(self.handle)
},
ReadCompression::Bzip2 => unsafe {
ffi::archive_read_support_compression_bzip2(self.handle);
ffi::archive_read_support_compression_bzip2(self.handle)
},
ReadCompression::Compress => unsafe {
ffi::archive_read_support_compression_compress(self.handle);
ffi::archive_read_support_compression_compress(self.handle)
},
ReadCompression::Gzip => unsafe {
ffi::archive_read_support_compression_gzip(self.handle);
ffi::archive_read_support_compression_gzip(self.handle)
},
ReadCompression::Lzip => unsafe {
ffi::archive_read_support_compression_lzip(self.handle);
ffi::archive_read_support_compression_lzip(self.handle)
},
ReadCompression::Lzma => unsafe {
ffi::archive_read_support_compression_lzma(self.handle);
ffi::archive_read_support_compression_lzma(self.handle)
},
ReadCompression::None => unsafe {
ffi::archive_read_support_compression_none(self.handle);
ffi::archive_read_support_compression_none(self.handle)
},
ReadCompression::Program(prog) => {
let c_prog = CString::new(prog).unwrap();
unsafe {
ffi::archive_read_support_compression_program(self.handle, c_prog.as_ptr());
ffi::archive_read_support_compression_program(self.handle, c_prog.as_ptr())
}
}
ReadCompression::Rpm => unsafe {
ffi::archive_read_support_compression_rpm(self.handle);
},
ReadCompression::Uu => unsafe {
ffi::archive_read_support_compression_uu(self.handle);
},
ReadCompression::Xz => unsafe {
ffi::archive_read_support_compression_xz(self.handle);
ffi::archive_read_support_compression_rpm(self.handle)
},
ReadCompression::Uu => unsafe { ffi::archive_read_support_compression_uu(self.handle) },
ReadCompression::Xz => unsafe { ffi::archive_read_support_compression_xz(self.handle) },
};
match result {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
ArchiveResult::from(self as &Handle)
}
pub fn support_filter(&mut self, filter: ReadFilter) -> ArchiveResult<()> {
match filter {
ReadFilter::All => unsafe {
ffi::archive_read_support_filter_all(self.handle);
},
ReadFilter::Bzip2 => unsafe {
ffi::archive_read_support_filter_bzip2(self.handle);
},
let result = match filter {
ReadFilter::All => unsafe { ffi::archive_read_support_filter_all(self.handle) },
ReadFilter::Bzip2 => unsafe { ffi::archive_read_support_filter_bzip2(self.handle) },
ReadFilter::Compress => unsafe {
ffi::archive_read_support_filter_compress(self.handle);
},
ReadFilter::Grzip => unsafe {
ffi::archive_read_support_filter_grzip(self.handle);
},
ReadFilter::Gzip => unsafe {
ffi::archive_read_support_filter_gzip(self.handle);
},
ReadFilter::Lrzip => unsafe {
ffi::archive_read_support_filter_lrzip(self.handle);
},
ReadFilter::Lzip => unsafe {
ffi::archive_read_support_filter_lzip(self.handle);
},
ReadFilter::Lzma => unsafe {
ffi::archive_read_support_filter_lzma(self.handle);
},
ReadFilter::Lzop => unsafe {
ffi::archive_read_support_filter_lzop(self.handle);
},
ReadFilter::None => unsafe {
ffi::archive_read_support_filter_none(self.handle);
ffi::archive_read_support_filter_compress(self.handle)
},
ReadFilter::Grzip => unsafe { ffi::archive_read_support_filter_grzip(self.handle) },
ReadFilter::Gzip => unsafe { ffi::archive_read_support_filter_gzip(self.handle) },
ReadFilter::Lrzip => unsafe { ffi::archive_read_support_filter_lrzip(self.handle) },
ReadFilter::Lzip => unsafe { ffi::archive_read_support_filter_lzip(self.handle) },
ReadFilter::Lzma => unsafe { ffi::archive_read_support_filter_lzma(self.handle) },
ReadFilter::Lzop => unsafe { ffi::archive_read_support_filter_lzop(self.handle) },
ReadFilter::None => unsafe { ffi::archive_read_support_filter_none(self.handle) },
ReadFilter::Program(prog) => {
let c_prog = CString::new(prog).unwrap();
unsafe {
ffi::archive_read_support_filter_program(self.handle, c_prog.as_ptr());
}
unsafe { ffi::archive_read_support_filter_program(self.handle, c_prog.as_ptr()) }
}
ReadFilter::ProgramSignature(prog, cb, size) => {
let c_prog = CString::new(prog).unwrap();
@@ -285,71 +264,43 @@ impl Builder {
ffi::archive_read_support_filter_program_signature(self.handle,
c_prog.as_ptr(),
mem::transmute(cb),
size);
size)
}
}
ReadFilter::Rpm => unsafe {
ffi::archive_read_support_filter_rpm(self.handle);
},
ReadFilter::Uu => unsafe {
ffi::archive_read_support_filter_uu(self.handle);
},
ReadFilter::Xz => unsafe {
ffi::archive_read_support_filter_xz(self.handle);
},
ReadFilter::Rpm => unsafe { ffi::archive_read_support_filter_rpm(self.handle) },
ReadFilter::Uu => unsafe { ffi::archive_read_support_filter_uu(self.handle) },
ReadFilter::Xz => unsafe { ffi::archive_read_support_filter_xz(self.handle) },
};
match result {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
ArchiveResult::from(self as &Handle)
}
pub fn support_format(&self, format: ReadFormat) -> ArchiveResult<()> {
match format {
ReadFormat::SevenZip => unsafe {
ffi::archive_read_support_format_7zip(self.handle());
},
ReadFormat::All => unsafe {
ffi::archive_read_support_format_all(self.handle());
},
ReadFormat::Ar => unsafe {
ffi::archive_read_support_format_ar(self.handle());
},
ReadFormat::Cab => unsafe {
ffi::archive_read_support_format_cab(self.handle());
},
ReadFormat::Cpio => unsafe {
ffi::archive_read_support_format_cpio(self.handle());
},
ReadFormat::Empty => unsafe {
ffi::archive_read_support_format_empty(self.handle());
},
ReadFormat::Gnutar => unsafe {
ffi::archive_read_support_format_gnutar(self.handle());
},
let result = match format {
ReadFormat::SevenZip => unsafe { ffi::archive_read_support_format_7zip(self.handle()) },
ReadFormat::All => unsafe { ffi::archive_read_support_format_all(self.handle()) },
ReadFormat::Ar => unsafe { ffi::archive_read_support_format_ar(self.handle()) },
ReadFormat::Cab => unsafe { ffi::archive_read_support_format_cab(self.handle()) },
ReadFormat::Cpio => unsafe { ffi::archive_read_support_format_cpio(self.handle()) },
ReadFormat::Empty => unsafe { ffi::archive_read_support_format_empty(self.handle()) },
ReadFormat::Gnutar => unsafe { ffi::archive_read_support_format_gnutar(self.handle()) },
ReadFormat::Iso9660 => unsafe {
ffi::archive_read_support_format_iso9660(self.handle());
},
ReadFormat::Lha => unsafe {
ffi::archive_read_support_format_lha(self.handle());
},
ReadFormat::Mtree => unsafe {
ffi::archive_read_support_format_mtree(self.handle());
},
ReadFormat::Rar => unsafe {
ffi::archive_read_support_format_rar(self.handle());
},
ReadFormat::Raw => unsafe {
ffi::archive_read_support_format_raw(self.handle());
},
ReadFormat::Tar => unsafe {
ffi::archive_read_support_format_tar(self.handle());
},
ReadFormat::Xar => unsafe {
ffi::archive_read_support_format_xar(self.handle());
},
ReadFormat::Zip => unsafe {
ffi::archive_read_support_format_zip(self.handle());
ffi::archive_read_support_format_iso9660(self.handle())
},
ReadFormat::Lha => unsafe { ffi::archive_read_support_format_lha(self.handle()) },
ReadFormat::Mtree => unsafe { ffi::archive_read_support_format_mtree(self.handle()) },
ReadFormat::Rar => unsafe { ffi::archive_read_support_format_rar(self.handle()) },
ReadFormat::Raw => unsafe { ffi::archive_read_support_format_raw(self.handle()) },
ReadFormat::Tar => unsafe { ffi::archive_read_support_format_tar(self.handle()) },
ReadFormat::Xar => unsafe { ffi::archive_read_support_format_xar(self.handle()) },
ReadFormat::Zip => unsafe { ffi::archive_read_support_format_zip(self.handle()) },
};
match result {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
ArchiveResult::from(self as &Handle)
}
pub fn open_file<T: AsRef<Path>>(self, file: T) -> ArchiveResult<FileReader> {
libraries/libarchive/src/writer.rs
+66 -96
View File
@@ -62,24 +62,30 @@ impl Disk {
pub fn set_bytes_per_block(&mut self, count: i32) -> ArchiveResult<()> {
unsafe {
ffi::archive_write_set_bytes_per_block(self.handle, count);
match ffi::archive_write_set_bytes_per_block(self.handle, count) {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
}
ArchiveResult::from(self as &Handle)
}
pub fn set_bytes_in_last_block(&mut self, count: i32) -> ArchiveResult<()> {
unsafe {
ffi::archive_write_set_bytes_in_last_block(self.handle, count);
match ffi::archive_write_set_bytes_in_last_block(self.handle, count) {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
}
ArchiveResult::from(self as &Handle)
}
// Set options for extraction built from `ExtractOptions`
pub fn set_options(&self, eopt: &ExtractOptions) -> ArchiveResult<()> {
unsafe {
ffi::archive_write_disk_set_options(self.handle, eopt.flags);
match ffi::archive_write_disk_set_options(self.handle, eopt.flags) {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
}
ArchiveResult::from(self as &Handle)
}
// This convenience function installs a standard set of user and group lookup functions. These
@@ -88,9 +94,11 @@ impl Disk {
// reduce the number of calls to getpwnam(3) and getgrnam(3).
pub fn set_standard_lookup(&self) -> ArchiveResult<()> {
unsafe {
ffi::archive_write_disk_set_standard_lookup(self.handle);
match ffi::archive_write_disk_set_standard_lookup(self.handle) {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
}
ArchiveResult::from(self as &Handle)
}
// * Failures - HeaderPosition
@@ -133,9 +141,11 @@ impl Disk {
pub fn close(&self) -> ArchiveResult<()> {
unsafe {
ffi::archive_write_close(self.handle());
match ffi::archive_write_close(self.handle()) {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
}
ArchiveResult::from(self as &Handle)
}
fn write_data<T: Reader>(&self, reader: &T) -> ArchiveResult<usize> {
@@ -164,9 +174,11 @@ impl Disk {
fn write_header(&self, entry: &ReaderEntry) -> ArchiveResult<()> {
unsafe {
ffi::archive_write_header(self.handle, entry.entry());
match ffi::archive_write_header(self.handle, entry.entry()) {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
}
ArchiveResult::from(self as &Handle)
}
}
@@ -190,6 +202,7 @@ impl Default for Disk {
impl Drop for Disk {
fn drop(&mut self) {
// JW TODO: do not close, libarchive will handle it
self.close().unwrap();
unsafe {
ffi::archive_write_free(self.handle());
@@ -203,107 +216,64 @@ impl Builder {
}
pub fn add_filter(&mut self, filter: WriteFilter) -> ArchiveResult<()> {
match filter {
let result = match filter {
WriteFilter::B64Encode => unsafe {
ffi::archive_write_add_filter_b64encode(self.handle);
},
WriteFilter::Bzip2 => unsafe {
ffi::archive_write_add_filter_bzip2(self.handle);
},
WriteFilter::Compress => unsafe {
ffi::archive_write_add_filter_compress(self.handle);
},
WriteFilter::Grzip => unsafe {
ffi::archive_write_add_filter_grzip(self.handle);
},
WriteFilter::Gzip => unsafe {
ffi::archive_write_add_filter_gzip(self.handle);
},
WriteFilter::Lrzip => unsafe {
ffi::archive_write_add_filter_lrzip(self.handle);
},
WriteFilter::Lzip => unsafe {
ffi::archive_write_add_filter_lzip(self.handle);
},
WriteFilter::Lzma => unsafe {
ffi::archive_write_add_filter_lzma(self.handle);
},
WriteFilter::Lzop => unsafe {
ffi::archive_write_add_filter_lzop(self.handle);
},
WriteFilter::None => unsafe {
ffi::archive_write_add_filter_none(self.handle);
ffi::archive_write_add_filter_b64encode(self.handle)
},
WriteFilter::Bzip2 => unsafe { ffi::archive_write_add_filter_bzip2(self.handle) },
WriteFilter::Compress => unsafe { ffi::archive_write_add_filter_compress(self.handle) },
WriteFilter::Grzip => unsafe { ffi::archive_write_add_filter_grzip(self.handle) },
WriteFilter::Gzip => unsafe { ffi::archive_write_add_filter_gzip(self.handle) },
WriteFilter::Lrzip => unsafe { ffi::archive_write_add_filter_lrzip(self.handle) },
WriteFilter::Lzip => unsafe { ffi::archive_write_add_filter_lzip(self.handle) },
WriteFilter::Lzma => unsafe { ffi::archive_write_add_filter_lzma(self.handle) },
WriteFilter::Lzop => unsafe { ffi::archive_write_add_filter_lzop(self.handle) },
WriteFilter::None => unsafe { ffi::archive_write_add_filter_none(self.handle) },
WriteFilter::Program(prog) => {
let c_prog = CString::new(prog).unwrap();
unsafe { ffi::archive_write_add_filter_program(self.handle, c_prog.as_ptr()) };
unsafe { ffi::archive_write_add_filter_program(self.handle, c_prog.as_ptr()) }
}
WriteFilter::UuEncode => unsafe {
ffi::archive_write_add_filter_uuencode(self.handle);
},
WriteFilter::Xz => unsafe {
ffi::archive_write_add_filter_xz(self.handle);
},
WriteFilter::UuEncode => unsafe { ffi::archive_write_add_filter_uuencode(self.handle) },
WriteFilter::Xz => unsafe { ffi::archive_write_add_filter_xz(self.handle) },
};
match result {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
ArchiveResult::from(self as &Handle)
}
pub fn set_format(&self, format: WriteFormat) -> ArchiveResult<()> {
match format {
WriteFormat::SevenZip => unsafe {
ffi::archive_write_set_format_7zip(self.handle);
},
WriteFormat::ArBsd => unsafe {
ffi::archive_write_set_format_ar_bsd(self.handle);
},
WriteFormat::ArSvr4 => unsafe {
ffi::archive_write_set_format_ar_svr4(self.handle);
},
WriteFormat::Cpio => unsafe {
ffi::archive_write_set_format_cpio(self.handle);
},
let result = match format {
WriteFormat::SevenZip => unsafe { ffi::archive_write_set_format_7zip(self.handle) },
WriteFormat::ArBsd => unsafe { ffi::archive_write_set_format_ar_bsd(self.handle) },
WriteFormat::ArSvr4 => unsafe { ffi::archive_write_set_format_ar_svr4(self.handle) },
WriteFormat::Cpio => unsafe { ffi::archive_write_set_format_cpio(self.handle) },
WriteFormat::CpioNewc => unsafe {
ffi::archive_write_set_format_cpio_newc(self.handle);
},
WriteFormat::Gnutar => unsafe {
ffi::archive_write_set_format_gnutar(self.handle);
},
WriteFormat::Iso9660 => unsafe {
ffi::archive_write_set_format_iso9660(self.handle);
},
WriteFormat::Mtree => unsafe {
ffi::archive_write_set_format_mtree(self.handle);
ffi::archive_write_set_format_cpio_newc(self.handle)
},
WriteFormat::Gnutar => unsafe { ffi::archive_write_set_format_gnutar(self.handle) },
WriteFormat::Iso9660 => unsafe { ffi::archive_write_set_format_iso9660(self.handle) },
WriteFormat::Mtree => unsafe { ffi::archive_write_set_format_mtree(self.handle) },
WriteFormat::MtreeClassic => unsafe {
ffi::archive_write_set_format_mtree_classic(self.handle);
},
WriteFormat::Pax => unsafe {
ffi::archive_write_set_format_pax(self.handle);
ffi::archive_write_set_format_mtree_classic(self.handle)
},
WriteFormat::Pax => unsafe { ffi::archive_write_set_format_pax(self.handle) },
WriteFormat::PaxRestricted => unsafe {
ffi::archive_write_set_format_pax_restricted(self.handle);
},
WriteFormat::Shar => unsafe {
ffi::archive_write_set_format_shar(self.handle);
ffi::archive_write_set_format_pax_restricted(self.handle)
},
WriteFormat::Shar => unsafe { ffi::archive_write_set_format_shar(self.handle) },
WriteFormat::SharDump => unsafe {
ffi::archive_write_set_format_shar_dump(self.handle);
},
WriteFormat::Ustar => unsafe {
ffi::archive_write_set_format_ustar(self.handle);
},
WriteFormat::V7tar => unsafe {
ffi::archive_write_set_format_v7tar(self.handle);
},
WriteFormat::Xar => unsafe {
ffi::archive_write_set_format_xar(self.handle);
},
WriteFormat::Zip => unsafe {
ffi::archive_write_set_format_zip(self.handle);
ffi::archive_write_set_format_shar_dump(self.handle)
},
WriteFormat::Ustar => unsafe { ffi::archive_write_set_format_ustar(self.handle) },
WriteFormat::V7tar => unsafe { ffi::archive_write_set_format_v7tar(self.handle) },
WriteFormat::Xar => unsafe { ffi::archive_write_set_format_xar(self.handle) },
WriteFormat::Zip => unsafe { ffi::archive_write_set_format_zip(self.handle) },
};
match result {
ffi::ARCHIVE_OK => Ok(()),
_ => ArchiveResult::from(self as &Handle),
}
ArchiveResult::from(self as &Handle)
}
pub fn open_file<T: AsRef<Path>>(mut self, file: T) -> ArchiveResult<Writer> {
@@ -313,7 +283,7 @@ impl Builder {
let c_file = CString::new(file.as_ref().to_string_lossy().as_bytes()).unwrap();
let res = unsafe { ffi::archive_write_open_filename(self.handle, c_file.as_ptr()) };
match res {
0 => {
ffi::ARCHIVE_OK => {
self.consumed = true;
Ok(Writer::new(self.handle))
}