pub fn test(file: &Vec<u8>) -> Result<FarArchive, String>Tests if a buffer is a valid FarArchive. +Returns a FarArchive struct if it is, or an error if it is not.
+use std::fs;
+use libfar::farlib;
+let buffer = fs::read("test.far").expect("Failed to read file");
+let test = farlib::test(&buffer);
+match test {
+ Ok(archive) => {
+ println!("test.far is a valid archive");
+ },
+ Err(e) => {
+ println!("test.far is not a valid archive: {}", e);
+ }
+}Struct containing information about an archive.
+Struct containing a file, whether or not it’s in an archive. +This should be used when creating a file from a buffer, or when getting files from an archive.
+Struct containing information about a file, without reading the actual data of the file. +This should be used in cases where file information is needed to be retrieved quickly +(e.g. when listing files in an archive).
+Tests if a buffer is a valid FarArchive. +Returns a FarArchive struct if it is, or an error if it is not.
+pub struct FarArchive {
+ pub version: u32,
+ pub file_count: u32,
+ pub file_list: Vec<FarFileInfo>,
+ pub file_data: Vec<FarFile>,
+}Struct containing information about an archive.
+Should be created by one of two ways:
+FarArchive::new_from_files if creating an archive from a list of FarFile structsfarlib::test(buffer) if loading an archive from a file/bufferversion: u32file_count: u32file_list: Vec<FarFileInfo>file_data: Vec<FarFile>Creates a new FarArchive struct from a list of FarFile structs. +Important when creating a new archive.
+// file_names is a Vec<String> containing the names of the files
+use std::fs;
+use libfar::farlib;
+let mut file_list = Vec::new();
+for file in file_names {
+ let file_name = file.split("/").last().unwrap();
+ let file_size = fs::metadata(file.clone()).expect("Failed to get file size").len();
+ let file_data = fs::read(file.clone()).expect("Failed to read file");
+ let file_obj = farlib::FarFile {
+ name: file_name.to_string(),
+ size: file_size as u32,
+ data: file_data
+ };
+ file_list.push(file_obj);
+}
+
+let archive = farlib::FarArchive::new_from_files(file_list);Loads file data into a FarArchive struct, used if a FarFileInfo struct is not sufficient.
+// buffer is a Vec<u8> containing the contents of a .far file
+use libfar::farlib;
+let test = farlib::test(&buffer);
+match test {
+ Ok(archive) => {
+ let archive = archive.load_file_data(&buffer);
+ }
+ Err(e) => {
+ println!("{} is not a valid archive: {}", archive_name, e);
+ }
+}Creates a buffer representing the contents of a FarArchive struct. +Can be written to a file to create a .far archive.
+// archive is a FarArchive struct
+// archive_name is the name of the file we will write the archive to
+use std::fs;
+use std::io::Write;
+use libfar::farlib;
+let buffer = archive.to_vec();
+let mut file = fs::File::create(archive_name.clone()).expect("Failed to create file");
+file.write_all(&*archive_obj.to_vec()).expect("Failed to write file");Struct containing a file, whether or not it’s in an archive. +This should be used when creating a file from a buffer, or when getting files from an archive.
+Should be created by calling FarFile::new_from_archive if extracting from an archive, or
+FarFile::new_from_file if reading from a buffer.
// buffer is a Vec<u8> containing the contents of a file
+// fileA_name is the name of the file
+use libfar::farlib::FarFile;
+let fileA = FarFile::new_from_file(fileA_name, buffer.len() as u32, buffer);
+
+// archive_buf is a Vec<u8> containing the contents of a .far file
+// fileB_name is the name of the file that we got from reading the manifest
+// fileB_size is the size of the file that we got from reading the manifest
+// fileB_offset is the offset of the file that we got from reading the manifest
+let fileB = FarFile::new_from_archive(fileB_name, fileB_size, fileB_offset, archive_buf);name: Stringsize: u32data: Vec<u8>Creates a new FarFile struct from an offset, size, and archive buffer.
+// archive_buf is a Vec<u8> containing the contents of a .far file
+// file_name is the name of the file that we got from reading the manifest
+// file_size is the size of the file that we got from reading the manifest
+// file_offset is the offset of the file that we got from reading the manifest
+use libfar::farlib::FarFile;
+let file = FarFile::new_from_archive(file_name, file_size, file_offset, archive_buf);Creates a new FarFile struct from a size, and data buffer.
+// buffer is a Vec<u8> containing the contents of a file
+// file_name is the name of the file
+use libfar::farlib::FarFile;
+let file = FarFile::new_from_file(file_name, buffer.len() as u32, buffer);Struct containing information about a file, without reading the actual data of the file. +This should be used in cases where file information is needed to be retrieved quickly +(e.g. when listing files in an archive).
+name: Stringsize: u32fn:) 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)","Search multiple things at once by splitting your query with comma (e.g., \
+ str,u8 or String,struct:Vec,test)","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(function(x){return""+x+"
"}).join("");var div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="
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 +
use std::io::{BufReader, Read};
+
+/// Struct containing information about a file, without reading the actual data of the file.
+/// This should be used in cases where file information is needed to be retrieved quickly
+/// (e.g. when listing files in an archive).
+pub struct FarFileInfo {
+ pub name: String,
+ pub size: u32,
+ offset: u32,
+}
+
+/// Struct containing a file, whether or not it's in an archive.
+/// This should be used when creating a file from a buffer, or when getting files from an archive.
+///
+/// Should be created by calling `FarFile::new_from_archive` if extracting from an archive, or
+/// `FarFile::new_from_file` if reading from a buffer.
+///
+/// # Examples
+/// ```
+/// // buffer is a Vec<u8> containing the contents of a file
+/// // fileA_name is the name of the file
+/// use libfar::farlib::FarFile;
+/// let fileA = FarFile::new_from_file(fileA_name, buffer.len() as u32, buffer);
+///
+/// // archive_buf is a Vec<u8> containing the contents of a .far file
+/// // fileB_name is the name of the file that we got from reading the manifest
+/// // fileB_size is the size of the file that we got from reading the manifest
+/// // fileB_offset is the offset of the file that we got from reading the manifest
+/// let fileB = FarFile::new_from_archive(fileB_name, fileB_size, fileB_offset, archive_buf);
+/// ```
+pub struct FarFile {
+ pub name: String,
+ pub size: u32,
+ pub data: Vec<u8>,
+}
+
+/// Struct containing information about an archive.
+///
+/// Should be created by one of two ways:
+/// 1. Calling `FarArchive::new_from_files` if creating an archive from a list of FarFile structs
+/// 2. Calling `farlib::test(buffer)` if loading an archive from a file/buffer
+pub struct FarArchive {
+ pub version: u32,
+ pub file_count: u32,
+ pub file_list: Vec<FarFileInfo>,
+ pub file_data: Vec<FarFile>,
+}
+
+impl FarFile {
+ /// Creates a new FarFile struct from an offset, size, and archive buffer.
+ ///
+ /// # Examples
+ /// ```
+ /// // archive_buf is a Vec<u8> containing the contents of a .far file
+ /// // file_name is the name of the file that we got from reading the manifest
+ /// // file_size is the size of the file that we got from reading the manifest
+ /// // file_offset is the offset of the file that we got from reading the manifest
+ /// use libfar::farlib::FarFile;
+ /// let file = FarFile::new_from_archive(file_name, file_size, file_offset, archive_buf);
+ /// ```
+ pub fn new_from_archive(name : String, size : u32, offset : u32, original_file : &Vec<u8>) -> FarFile {
+ let mut reader = BufReader::new(&original_file[offset as usize..(offset + size) as usize]);
+ let mut data = Vec::new();
+ reader.read_to_end(&mut data).expect("Failed to read file data");
+ FarFile {
+ name,
+ size,
+ data,
+ }
+ }
+
+ /// Creates a new FarFile struct from a size, and data buffer.
+ ///
+ /// # Examples
+ /// ```
+ /// // buffer is a Vec<u8> containing the contents of a file
+ /// // file_name is the name of the file
+ /// use libfar::farlib::FarFile;
+ /// let file = FarFile::new_from_file(file_name, buffer.len() as u32, buffer);
+ /// ```
+ pub fn new_from_file(name : String, size : u32, data : Vec<u8>) -> FarFile {
+ FarFile {
+ name,
+ size,
+ data,
+ }
+ }
+}
+
+impl FarArchive {
+ /// Creates a new FarArchive struct from a list of FarFile structs.
+ /// Important when creating a new archive.
+ ///
+ /// # Examples
+ /// ```
+ /// // file_names is a Vec<String> containing the names of the files
+ /// use std::fs;
+ /// use libfar::farlib;
+ /// let mut file_list = Vec::new();
+ /// for file in file_names {
+ /// let file_name = file.split("/").last().unwrap();
+ /// let file_size = fs::metadata(file.clone()).expect("Failed to get file size").len();
+ /// let file_data = fs::read(file.clone()).expect("Failed to read file");
+ /// let file_obj = farlib::FarFile {
+ /// name: file_name.to_string(),
+ /// size: file_size as u32,
+ /// data: file_data
+ /// };
+ /// file_list.push(file_obj);
+ /// }
+ ///
+ /// let archive = farlib::FarArchive::new_from_files(file_list);
+ /// ```
+ pub fn new_from_files(files : Vec<FarFile>) -> FarArchive {
+ let mut file_list = Vec::new();
+ let mut file_data = Vec::new();
+ let mut offset = 0;
+ for file in files {
+ offset += &file.size;
+ file_list.push(FarFileInfo {
+ name: file.name.clone(),
+ size: file.size,
+ offset,
+ });
+ file_data.push(file);
+ }
+ FarArchive {
+ version: 1,
+ file_count: file_list.len() as u32,
+ file_list,
+ file_data,
+ }
+ }
+
+ /// Loads file data into a FarArchive struct, used if a FarFileInfo struct is not sufficient.
+ ///
+ /// # Examples
+ /// ```
+ /// // buffer is a Vec<u8> containing the contents of a .far file
+ /// use libfar::farlib;
+ /// let test = farlib::test(&buffer);
+ /// match test {
+ /// Ok(archive) => {
+ /// let archive = archive.load_file_data(&buffer);
+ /// }
+ /// Err(e) => {
+ /// println!("{} is not a valid archive: {}", archive_name, e);
+ /// }
+ /// }
+ /// ```
+ pub fn load_file_data(self, original_file : &Vec<u8>) -> FarArchive {
+ let mut new_file_data = Vec::new();
+ for i in 0..self.file_list.len() {
+ new_file_data.push(FarFile::new_from_archive(
+ self.file_list[i].name.clone(),
+ self.file_list[i].size,
+ self.file_list[i].offset,
+ original_file,
+ ));
+ }
+ FarArchive {
+ version: self.version,
+ file_count: self.file_count,
+ file_list: self.file_list,
+ file_data: new_file_data,
+ }
+ }
+
+ /// Creates a buffer representing the contents of a FarArchive struct.
+ /// Can be written to a file to create a .far archive.
+ ///
+ /// # Examples
+ /// ```
+ /// // archive is a FarArchive struct
+ /// // archive_name is the name of the file we will write the archive to
+ /// use std::fs;
+ /// use std::io::Write;
+ /// use libfar::farlib;
+ /// let buffer = archive.to_vec();
+ /// let mut file = fs::File::create(archive_name.clone()).expect("Failed to create file");
+ /// file.write_all(&*archive_obj.to_vec()).expect("Failed to write file");
+ /// ```
+ pub fn to_vec(self) -> Vec<u8> {
+ // write header
+ let mut header = Vec::new();
+ for c in "FAR!byAZ".chars() {
+ header.push(c as u8);
+ }
+ header.extend(&self.version.to_le_bytes());
+ // wait to write manifest offset until calculated later
+ // write file data
+ let mut file_data = Vec::new(); // actual data to be written to file
+ let mut file_list = Vec::new(); // file list used for making manifest later on
+ let mut bytes_written = 16; // where we should start putting files
+ for i in 0..self.file_data.len() {
+ let mut file_data_bytes = Vec::new();
+ file_data_bytes.extend_from_slice(&self.file_data[i].data);
+ file_data.extend_from_slice(&file_data_bytes);
+ file_list.push(FarFileInfo {
+ name: self.file_data[i].name.clone(),
+ size: self.file_data[i].size,
+ offset: bytes_written,
+ });
+ bytes_written += self.file_data[i].size;
+ }
+ // write manifest
+ let mut manifest = Vec::new();
+ // write file count
+ manifest.extend_from_slice(&self.file_count.to_le_bytes());
+ // for each file, write (size, size, offset, name length, name)
+ for i in 0..self.file_list.len() {
+ manifest.extend_from_slice(&file_list[i].size.to_le_bytes());
+ manifest.extend_from_slice(&file_list[i].size.to_le_bytes());
+ manifest.extend_from_slice(&file_list[i].offset.to_le_bytes());
+ manifest.extend_from_slice(&(file_list[i].name.len() as u32).to_le_bytes());
+ manifest.extend_from_slice(&file_list[i].name.as_bytes());
+ }
+ // write manifest offset
+ let manifest_offset = bytes_written;
+ header.extend_from_slice(&manifest_offset.to_le_bytes());
+
+ // join vecs together
+ let mut output = Vec::new();
+ output.extend_from_slice(&header);
+ output.extend_from_slice(&file_data);
+ output.extend_from_slice(&manifest);
+ output
+ }
+}
+
+/// Tests if a buffer is a valid FarArchive.
+/// Returns a FarArchive struct if it is, or an error if it is not.
+///
+/// # Examples
+/// ```
+/// use std::fs;
+/// use libfar::farlib;
+/// let buffer = fs::read("test.far").expect("Failed to read file");
+/// let test = farlib::test(&buffer);
+/// match test {
+/// Ok(archive) => {
+/// println!("test.far is a valid archive");
+/// },
+/// Err(e) => {
+/// println!("test.far is not a valid archive: {}", e);
+/// }
+/// }
+/// ```
+pub fn test(file : &Vec<u8>) -> Result<FarArchive, String> {
+ let mut reader = BufReader::new(&file[..]);
+ let mut magic = [0u8; 8];
+ reader.read_exact(&mut magic).unwrap();
+ if magic != *b"FAR!byAZ" {
+ return Err("Not a Far archive".to_string());
+ }
+ let mut version = [0; 4];
+ reader.read_exact(&mut version).unwrap();
+ let version = u32::from_le_bytes(version);
+ // get list of files
+ let files = list_files(file).expect("Failed to list files");
+ Ok(FarArchive {
+ version,
+ file_count: files.len() as u32,
+ file_list: files,
+ file_data: vec![],
+ })
+}
+
+fn list_files(file : &Vec<u8>) -> Result<Vec<FarFileInfo>, String> {
+ // manifest offset is at 12 bytes (u32)
+ let mut reader = BufReader::new(&file[12..]);
+ let mut offset = [0u8; 4];
+ reader.read_exact(&mut offset).unwrap();
+ let offset = u32::from_le_bytes(offset);
+ // move to manifest
+ reader = BufReader::new(&file[offset as usize..]);
+ // read u32 for number of files
+ let mut num_files = [0u8; 4];
+ reader.read_exact(&mut num_files).unwrap();
+ let num_files = u32::from_le_bytes(num_files);
+ // for each file, read u32 for size, u32 for size again (stored twice for some reason), u32 for offset, u32 for name length, name
+ let mut files = Vec::new();
+ for i in 0..num_files {
+ let mut size = [0u8; 4];
+ reader.read_exact(&mut size).expect(format!("Failed to read size for file {}", i).as_str());
+ let size = u32::from_le_bytes(size);
+ let mut size2 = [0u8; 4];
+ reader.read_exact(&mut size2).expect(format!("Failed to read size for file {}", i).as_str());
+ let _size2 = u32::from_le_bytes(size2); // why is this stored twice? f*** you EA
+ let mut offset = [0u8; 4];
+ reader.read_exact(&mut offset).expect(format!("Failed to read offset for file {}", i).as_str());
+ let offset = u32::from_le_bytes(offset);
+ let mut name_len = [0u8; 4];
+ reader.read_exact(&mut name_len).expect(format!("Failed to read name length for file {}", i).as_str());
+ let name_len = u32::from_le_bytes(name_len);
+ let mut name = vec![0u8; name_len as usize];
+ reader.read_exact(&mut name).expect(format!("Failed to read name for file {}", i).as_str());
+ files.push(FarFileInfo {
+ name: String::from_utf8(name).unwrap(),
+ size,
+ offset,
+ });
+ }
+ Ok(files)
+}1
+pub mod farlib;