rzbackup 3.3.0

RZBackup
Documentation 
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

use std::path::Path;

use protobuf::stream::CodedInputStream;

use misc::*;
use zbackup::data::*;
use zbackup::disk_format::*;
use zbackup::disk_format::protobuf_types as raw;

pub struct DiskBackupInfo {
	raw: raw::BackupInfo,
}

impl DiskBackupInfo {

	pub fn read (
		coded_input_stream: & mut CodedInputStream,
	) -> Result <DiskBackupInfo, String> {

		Ok (DiskBackupInfo {
			raw: protobuf_message_read (
				coded_input_stream,
				|| format! (
					"backup info"),
			) ?,
		})

	}

	pub fn sha256 (& self) -> [u8; 32] {
		to_array_32 (self.raw.get_sha256 ())
	}

	pub fn backup_data (& self) -> & [u8] {
		& self.raw.get_backup_data ()
	}

	pub fn iterations (& self) -> u32 {
		self.raw.get_iterations ()
	}

}

#[ inline ]
pub fn backup_read_path <
	BackupPath: AsRef <Path>,
> (
	backup_path: BackupPath,
	encryption_key: Option <EncryptionKey>,
) -> Result <DiskBackupInfo, String> {

	backup_read_path_impl (
		backup_path.as_ref (),
		encryption_key,
	)

}

pub fn backup_read_path_impl (
	backup_path: & Path,
	encryption_key: Option <[u8; KEY_SIZE]>,
) -> Result <DiskBackupInfo, String> {

	let backup_info: DiskBackupInfo;

	// open file

	let mut source =
		io_result_with_prefix (
			|| format! (
				"Error reading {}: ",
				backup_path.to_string_lossy ()),
			file_open_with_crypto_and_adler (
				backup_path,
				encryption_key),
		) ?;

	{

		let mut coded_input_stream =
			CodedInputStream::from_buffered_reader (
				& mut source);

		// read file header

		let file_header: DiskFileHeader =
			DiskFileHeader::read (
				& mut coded_input_stream,
			) ?;

		if file_header.version () != 1 {

			panic! (
				"Unsupported backup version {}",
				file_header.version ());

		}

		// read backup info

		backup_info =
			DiskBackupInfo::read (
				& mut coded_input_stream,
			) ?;

	}

	// verify checksum

	adler_verify_hash_and_eof (
		|| format! (
			"Error reading {}: ",
			backup_path.to_string_lossy ()),
		source,
	) ?;

	// return

	Ok (backup_info)

}

// ex: noet ts=4 filetype=rust