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

//! Wraps the underlying FFI struct `lzma_stream` to provide various safety guarantees, like the Send trait.

use lzma_sys::*;
use error::{LzmaError, LzmaLibResult};
use std::ptr;


pub struct LzmaStreamWrapper {
	stream: lzma_stream,
}

pub struct LzmaCodeResult {
	/// The return value of lzma_code
	pub ret: LzmaLibResult,
	/// The number of bytes read from input
	pub bytes_read: usize,
	/// The number of bytes written to output
	pub bytes_written: usize,
}


// I believe liblzma is at least Send thread safe, though using it like that will result in
// malloc being called in one thread and free being called in another.  That's usually safe,
// but depends on how liblzma was compiled.
unsafe impl Send for LzmaStreamWrapper {}


impl LzmaStreamWrapper {
	pub fn new() -> LzmaStreamWrapper {
		LzmaStreamWrapper {
			stream: lzma_stream::new(),
		}
	}

	pub fn easy_encoder(&mut self, preset: u32, check: lzma_check) -> Result<(), LzmaError> {
		unsafe {
			LzmaLibResult::from(lzma_easy_encoder(&mut self.stream, preset, check)).map(|_| ())
		}
	}

	pub fn stream_decoder(&mut self, memlimit: u64, flags: u32) -> Result<(), LzmaError> {
		unsafe {
			LzmaLibResult::from(lzma_stream_decoder(&mut self.stream, memlimit, flags)).map(|_| ())
		}
	}

	pub fn end(&mut self) {
		unsafe {
			lzma_end(&mut self.stream)
		}
	}

	/// Pointers to input and output are given to liblzma during execution of this function,
	/// but they are removed before returning.  So that should keep everything safe.
	pub fn code(&mut self, input: &[u8], output: &mut [u8], action: lzma_action) -> LzmaCodeResult {
		// Prepare lzma_stream
		self.stream.next_in = input.as_ptr();
		self.stream.avail_in = input.len();
		self.stream.next_out = output.as_mut_ptr();
		self.stream.avail_out = output.len();

		// Execute lzma_code and get results
		let ret = unsafe {
			LzmaLibResult::from(lzma_code(&mut self.stream, action))
		};
		let bytes_read = input.len() - self.stream.avail_in;
		let bytes_written = output.len() - self.stream.avail_out;

		// Clear pointers from lzma_stream
		self.stream.next_in = ptr::null();
		self.stream.avail_in = 0;
		self.stream.next_out = ptr::null_mut();
		self.stream.avail_out = 0;

		LzmaCodeResult {
			ret: ret,
			bytes_read: bytes_read,
			bytes_written: bytes_written,
		}
	}
}