Unified · Split
| @@ -1,207 +0,0 @@ | |||
| 1 | use object::{Id, Kind}; | ||
| 2 | |||
| 3 | use walkdir::WalkDir; | ||
| 4 | use failure::{Error, ResultExt}; | ||
| 5 | use hex::{FromHex, ToHex}; | ||
| 6 | use smallvec::SmallVec; | ||
| 7 | use std::{fs::File, io::{Cursor, Read}, path::PathBuf}; | ||
| 8 | use std::os::unix::fs::MetadataExt; | ||
| 9 | use zlib; | ||
| 10 | use object::parsed; | ||
| 11 | |||
| 12 | const HEADER_READ_COMPRESSED_BYTES: usize = 512; | ||
| 13 | const HEADER_READ_UNCOMPRESSED_BYTES: usize = 1024; | ||
| 14 | |||
| 15 | pub struct Db { | ||
| 16 | pub path: PathBuf, | ||
| 17 | } | ||
| 18 | |||
| 19 | pub struct Object { | ||
| 20 | pub kind: Kind, | ||
| 21 | pub size: usize, | ||
| 22 | decompressed_data: SmallVec<[u8; HEADER_READ_UNCOMPRESSED_BYTES]>, | ||
| 23 | compressed_data: SmallVec<[u8; HEADER_READ_COMPRESSED_BYTES]>, | ||
| 24 | header_size: usize, | ||
| 25 | path: Option<PathBuf>, | ||
| 26 | is_decompressed: bool, | ||
| 27 | } | ||
| 28 | |||
| 29 | impl Object { | ||
| 30 | pub fn parsed(&mut self) -> Result<parsed::Object, Error> { | ||
| 31 | Ok(match self.kind { | ||
| 32 | Kind::Tag | Kind::Commit | Kind::Tree => { | ||
| 33 | if !self.is_decompressed { | ||
| 34 | let total_size = self.header_size + self.size; | ||
| 35 | let cap = self.decompressed_data.capacity(); | ||
| 36 | if cap < total_size { | ||
| 37 | self.decompressed_data.reserve_exact(total_size - cap); | ||
| 38 | } | ||
| 39 | unsafe { | ||
| 40 | debug_assert!(self.decompressed_data.capacity() >= total_size); | ||
| 41 | self.decompressed_data.set_len(total_size); | ||
| 42 | } | ||
| 43 | let mut cursor = Cursor::new(&mut self.decompressed_data[..]); | ||
| 44 | // TODO Performance opportunity | ||
| 45 | // here we do a lot of additional work, which could be saved if we | ||
| 46 | // could re-use the previous state. This doesn't work for some reason. | ||
| 47 | let mut deflate = zlib::Inflate::default(); | ||
| 48 | deflate.all_till_done(&self.compressed_data[..], &mut cursor)?; | ||
| 49 | self.is_decompressed = deflate.is_done; | ||
| 50 | debug_assert!(deflate.is_done); | ||
| 51 | self.compressed_data = Default::default(); | ||
| 52 | } | ||
| 53 | let bytes = &self.decompressed_data[self.header_size..]; | ||
| 54 | match self.kind { | ||
| 55 | Kind::Tag => parsed::Object::Tag(parsed::Tag::from_bytes(bytes)?), | ||
| 56 | _ => unimplemented!(), | ||
| 57 | } | ||
| 58 | } | ||
| 59 | Kind::Blob => unimplemented!(), | ||
| 60 | }) | ||
| 61 | } | ||
| 62 | } | ||
| 63 | |||
| 64 | impl Db { | ||
| 65 | pub fn iter(&self) -> impl Iterator<Item = Result<Id, Error>> { | ||
| 66 | use std::path::Component::Normal; | ||
| 67 | WalkDir::new(&self.path) | ||
| 68 | .min_depth(2) | ||
| 69 | .max_depth(3) | ||
| 70 | .follow_links(false) | ||
| 71 | .into_iter() | ||
| 72 | .filter_map(|e| { | ||
| 73 | let mut is_valid_path = false; | ||
| 74 | let e = e.map_err(Error::from).map(|e| { | ||
| 75 | let p = e.path(); | ||
| 76 | let (c1, c2) = p.components() | ||
| 77 | .fold((None, None), |(_c1, c2), cn| (c2, Some(cn))); | ||
| 78 | if let (Some(Normal(c1)), Some(Normal(c2))) = (c1, c2) { | ||
| 79 | if c1.len() == 2 && c2.len() == 38 { | ||
| 80 | if let (Some(c1), Some(c2)) = (c1.to_str(), c2.to_str()) { | ||
| 81 | let mut buf = [0u8; 40]; | ||
| 82 | { | ||
| 83 | let (first_byte, rest) = buf.split_at_mut(2); | ||
| 84 | first_byte.copy_from_slice(c1.as_bytes()); | ||
| 85 | rest.copy_from_slice(c2.as_bytes()); | ||
| 86 | } | ||
| 87 | if let Ok(b) = <[u8; 20]>::from_hex(&buf[..]) { | ||
| 88 | is_valid_path = true; | ||
| 89 | return b; | ||
| 90 | } | ||
| 91 | } | ||
| 92 | } | ||
| 93 | } | ||
| 94 | [0u8; 20] | ||
| 95 | }); | ||
| 96 | if is_valid_path { | ||
| 97 | Some(e) | ||
| 98 | } else { | ||
| 99 | None | ||
| 100 | } | ||
| 101 | }) | ||
| 102 | } | ||
| 103 | |||
| 104 | pub fn find(&self, id: &Id) -> Result<Object, Error> { | ||
| 105 | let path = sha1_path(id, self.path.clone()); | ||
| 106 | |||
| 107 | let mut deflate = zlib::Inflate::default(); | ||
| 108 | let mut decompressed = [0; HEADER_READ_UNCOMPRESSED_BYTES]; | ||
| 109 | let mut compressed = [0; HEADER_READ_COMPRESSED_BYTES]; | ||
| 110 | let ((_status, _consumed_in, consumed_out), bytes_read, mut input_stream) = { | ||
| 111 | let mut istream = File::open(&path)?; | ||
| 112 | let bytes_read = istream.read(&mut compressed[..])?; | ||
| 113 | let mut out = Cursor::new(&mut decompressed[..]); | ||
| 114 | |||
| 115 | ( | ||
| 116 | deflate | ||
| 117 | .once(&compressed[..bytes_read], &mut out) | ||
| 118 | .with_context(|_| { | ||
| 119 | format!("ZIP inflating failed while reading '{}'", path.display()) | ||
| 120 | })?, | ||
| 121 | bytes_read, | ||
| 122 | istream, | ||
| 123 | ) | ||
| 124 | }; | ||
| 125 | |||
| 126 | let (kind, size, header_size) = | ||
| 127 | parse::header(&decompressed[..consumed_out]).with_context(|_| { | ||
| 128 | format!( | ||
| 129 | "Invalid header layout at '{}', expected '<type> <size>'", | ||
| 130 | path.display() | ||
| 131 | ) | ||
| 132 | })?; | ||
| 133 | |||
| 134 | let decompressed = SmallVec::from_buf(decompressed); | ||
| 135 | let mut compressed = SmallVec::from_buf(compressed); | ||
| 136 | |||
| 137 | let path = match kind { | ||
| 138 | Kind::Tag | Kind::Commit | Kind::Tree => { | ||
| 139 | let fsize = input_stream.metadata()?.size(); | ||
| 140 | assert!(fsize <= ::std::usize::MAX as u64); | ||
| 141 | let fsize = fsize as usize; | ||
| 142 | if bytes_read == fsize { | ||
| 143 | None | ||
| 144 | } else { | ||
| 145 | let cap = compressed.capacity(); | ||
| 146 | if cap < fsize { | ||
| 147 | compressed.reserve_exact(fsize - cap); | ||
| 148 | debug_assert!(fsize == compressed.capacity()); | ||
| 149 | } | ||
| 150 | unsafe { | ||
| 151 | compressed.set_len(fsize); | ||
| 152 | } | ||
| 153 | input_stream.read_exact(&mut compressed[bytes_read..])?; | ||
| 154 | None | ||
| 155 | } | ||
| 156 | } | ||
| 157 | Kind::Blob => Some(path), // we will open the file again when needed. Maybe we can load small sized objects anyway | ||
| 158 | }; | ||
| 159 | |||
| 160 | Ok(Object { | ||
| 161 | kind, | ||
| 162 | size, | ||
| 163 | decompressed_data: decompressed, | ||
| 164 | compressed_data: compressed, | ||
| 165 | header_size, | ||
| 166 | path, | ||
| 167 | is_decompressed: deflate.is_done, | ||
| 168 | }) | ||
| 169 | } | ||
| 170 | } | ||
| 171 | |||
| 172 | pub mod parse { | ||
| 173 | use failure::{err_msg, Error}; | ||
| 174 | |||
| 175 | use object; | ||
| 176 | use std::str; | ||
| 177 | |||
| 178 | pub fn header(input: &[u8]) -> Result<(object::Kind, usize, usize), Error> { | ||
| 179 | let header_end = input | ||
| 180 | .iter() | ||
| 181 | .position(|&b| b == 0) | ||
| 182 | .ok_or_else(|| err_msg("Invalid header, did not find 0 byte"))?; | ||
| 183 | let header = &input[..header_end]; | ||
| 184 | let mut split = header.split(|&b| b == b' '); | ||
| 185 | match (split.next(), split.next()) { | ||
| 186 | (Some(kind), Some(size)) => Ok(( | ||
| 187 | object::Kind::from_bytes(kind)?, | ||
| 188 | str::from_utf8(size)?.parse()?, | ||
| 189 | header_end + 1, // account for 0 byte | ||
| 190 | )), | ||
| 191 | _ => bail!("expected '<type> <size>'"), | ||
| 192 | } | ||
| 193 | } | ||
| 194 | } | ||
| 195 | |||
| 196 | fn sha1_path(id: &[u8; 20], mut root: PathBuf) -> PathBuf { | ||
| 197 | let mut buf = String::with_capacity(40); | ||
| 198 | id.write_hex(&mut buf) | ||
| 199 | .expect("no failure as everything is preset by now"); | ||
| 200 | root.push(&buf[..2]); | ||
| 201 | root.push(&buf[2..]); | ||
| 202 | root | ||
| 203 | } | ||
| 204 | |||
| 205 | pub fn at(path: impl Into<PathBuf>) -> Db { | ||
| 206 | Db { path: path.into() } | ||
| 207 | } | ||
| @@ -0,0 +1,214 @@ | |||
| 1 | const HEADER_READ_COMPRESSED_BYTES: usize = 512; | ||
| 2 | const HEADER_READ_UNCOMPRESSED_BYTES: usize = 1024; | ||
| 3 | |||
| 4 | mod object { | ||
| 5 | use object::{parsed, Kind}; | ||
| 6 | use failure::Error; | ||
| 7 | use smallvec::SmallVec; | ||
| 8 | use std::{io::Cursor, path::PathBuf}; | ||
| 9 | use zlib; | ||
| 10 | use loose::{HEADER_READ_COMPRESSED_BYTES, HEADER_READ_UNCOMPRESSED_BYTES}; | ||
| 11 | |||
| 12 | pub struct Object { | ||
| 13 | pub kind: Kind, | ||
| 14 | pub size: usize, | ||
| 15 | decompressed_data: SmallVec<[u8; HEADER_READ_UNCOMPRESSED_BYTES]>, | ||
| 16 | compressed_data: SmallVec<[u8; HEADER_READ_COMPRESSED_BYTES]>, | ||
| 17 | header_size: usize, | ||
| 18 | _path: Option<PathBuf>, | ||
| 19 | is_decompressed: bool, | ||
| 20 | } | ||
| 21 | |||
| 22 | impl Object { | ||
| 23 | pub fn parsed(&mut self) -> Result<parsed::Object, Error> { | ||
| 24 | Ok(match self.kind { | ||
| 25 | Kind::Tag | Kind::Commit | Kind::Tree => { | ||
| 26 | if !self.is_decompressed { | ||
| 27 | let total_size = self.header_size + self.size; | ||
| 28 | let cap = self.decompressed_data.capacity(); | ||
| 29 | if cap < total_size { | ||
| 30 | self.decompressed_data.reserve_exact(total_size - cap); | ||
| 31 | } | ||
| 32 | unsafe { | ||
| 33 | debug_assert!(self.decompressed_data.capacity() >= total_size); | ||
| 34 | self.decompressed_data.set_len(total_size); | ||
| 35 | } | ||
| 36 | let mut cursor = Cursor::new(&mut self.decompressed_data[..]); | ||
| 37 | // TODO Performance opportunity | ||
| 38 | // here we do a lot of additional work, which could be saved if we | ||
| 39 | // could re-use the previous state. This doesn't work for some reason. | ||
| 40 | let mut deflate = zlib::Inflate::default(); | ||
| 41 | deflate.all_till_done(&self.compressed_data[..], &mut cursor)?; | ||
| 42 | self.is_decompressed = deflate.is_done; | ||
| 43 | debug_assert!(deflate.is_done); | ||
| 44 | self.compressed_data = Default::default(); | ||
| 45 | } | ||
| 46 | let bytes = &self.decompressed_data[self.header_size..]; | ||
| 47 | match self.kind { | ||
| 48 | Kind::Tag => parsed::Object::Tag(parsed::Tag::from_bytes(bytes)?), | ||
| 49 | _ => unimplemented!(), | ||
| 50 | } | ||
| 51 | } | ||
| 52 | Kind::Blob => unimplemented!(), | ||
| 53 | }) | ||
| 54 | } | ||
| 55 | } | ||
| 56 | } | ||
| 57 | |||
| 58 | mod db { | ||
| 59 | use object::{Id, Kind}; | ||
| 60 | |||
| 61 | use walkdir::WalkDir; | ||
| 62 | use failure::{err_msg, Error, ResultExt}; | ||
| 63 | use hex::{FromHex, ToHex}; | ||
| 64 | use smallvec::SmallVec; | ||
| 65 | use std::{str, fs::File, io::{Cursor, Read}, path::PathBuf}; | ||
| 66 | use std::os::unix::fs::MetadataExt; | ||
| 67 | use zlib; | ||
| 68 | use loose::{Object, HEADER_READ_COMPRESSED_BYTES, HEADER_READ_UNCOMPRESSED_BYTES}; | ||
| 69 | |||
| 70 | pub struct Db { | ||
| 71 | pub path: PathBuf, | ||
| 72 | } | ||
| 73 | |||
| 74 | impl Db { | ||
| 75 | pub fn iter(&self) -> impl Iterator<Item = Result<Id, Error>> { | ||
| 76 | use std::path::Component::Normal; | ||
| 77 | WalkDir::new(&self.path) | ||
| 78 | .min_depth(2) | ||
| 79 | .max_depth(3) | ||
| 80 | .follow_links(false) | ||
| 81 | .into_iter() | ||
| 82 | .filter_map(|e| { | ||
| 83 | let mut is_valid_path = false; | ||
| 84 | let e = e.map_err(Error::from).map(|e| { | ||
| 85 | let p = e.path(); | ||
| 86 | let (c1, c2) = p.components() | ||
| 87 | .fold((None, None), |(_c1, c2), cn| (c2, Some(cn))); | ||
| 88 | if let (Some(Normal(c1)), Some(Normal(c2))) = (c1, c2) { | ||
| 89 | if c1.len() == 2 && c2.len() == 38 { | ||
| 90 | if let (Some(c1), Some(c2)) = (c1.to_str(), c2.to_str()) { | ||
| 91 | let mut buf = [0u8; 40]; | ||
| 92 | { | ||
| 93 | let (first_byte, rest) = buf.split_at_mut(2); | ||
| 94 | first_byte.copy_from_slice(c1.as_bytes()); | ||
| 95 | rest.copy_from_slice(c2.as_bytes()); | ||
| 96 | } | ||
| 97 | if let Ok(b) = <[u8; 20]>::from_hex(&buf[..]) { | ||
| 98 | is_valid_path = true; | ||
| 99 | return b; | ||
| 100 | } | ||
| 101 | } | ||
| 102 | } | ||
| 103 | } | ||
| 104 | [0u8; 20] | ||
| 105 | }); | ||
| 106 | if is_valid_path { | ||
| 107 | Some(e) | ||
| 108 | } else { | ||
| 109 | None | ||
| 110 | } | ||
| 111 | }) | ||
| 112 | } | ||
| 113 | |||
| 114 | pub fn find(&self, id: &Id) -> Result<Object, Error> { | ||
| 115 | let path = sha1_path(id, self.path.clone()); | ||
| 116 | |||
| 117 | let mut deflate = zlib::Inflate::default(); | ||
| 118 | let mut decompressed = [0; HEADER_READ_UNCOMPRESSED_BYTES]; | ||
| 119 | let mut compressed = [0; HEADER_READ_COMPRESSED_BYTES]; | ||
| 120 | let ((_status, _consumed_in, consumed_out), bytes_read, mut input_stream) = { | ||
| 121 | let mut istream = File::open(&path)?; | ||
| 122 | let bytes_read = istream.read(&mut compressed[..])?; | ||
| 123 | let mut out = Cursor::new(&mut decompressed[..]); | ||
| 124 | |||
| 125 | ( | ||
| 126 | deflate | ||
| 127 | .once(&compressed[..bytes_read], &mut out) | ||
| 128 | .with_context(|_| { | ||
| 129 | format!("ZIP inflating failed while reading '{}'", path.display()) | ||
| 130 | })?, | ||
| 131 | bytes_read, | ||
| 132 | istream, | ||
| 133 | ) | ||
| 134 | }; | ||
| 135 | |||
| 136 | let (kind, size, header_size) = parse_header(&decompressed[..consumed_out]) | ||
| 137 | .with_context(|_| { | ||
| 138 | format!( | ||
| 139 | "Invalid header layout at '{}', expected '<type> <size>'", | ||
| 140 | path.display() | ||
| 141 | ) | ||
| 142 | })?; | ||
| 143 | |||
| 144 | let decompressed = SmallVec::from_buf(decompressed); | ||
| 145 | let mut compressed = SmallVec::from_buf(compressed); | ||
| 146 | |||
| 147 | let path = match kind { | ||
| 148 | Kind::Tag | Kind::Commit | Kind::Tree => { | ||
| 149 | let fsize = input_stream.metadata()?.size(); | ||
| 150 | assert!(fsize <= ::std::usize::MAX as u64); | ||
| 151 | let fsize = fsize as usize; | ||
| 152 | if bytes_read == fsize { | ||
| 153 | None | ||
| 154 | } else { | ||
| 155 | let cap = compressed.capacity(); | ||
| 156 | if cap < fsize { | ||
| 157 | compressed.reserve_exact(fsize - cap); | ||
| 158 | debug_assert!(fsize == compressed.capacity()); | ||
| 159 | } | ||
| 160 | unsafe { | ||
| 161 | compressed.set_len(fsize); | ||
| 162 | } | ||
| 163 | input_stream.read_exact(&mut compressed[bytes_read..])?; | ||
| 164 | None | ||
| 165 | } | ||
| 166 | } | ||
| 167 | Kind::Blob => Some(path), // we will open the file again when needed. Maybe we can load small sized objects anyway | ||
| 168 | }; | ||
| 169 | |||
| 170 | Ok(Object { | ||
| 171 | kind, | ||
| 172 | size, | ||
| 173 | decompressed_data: decompressed, | ||
| 174 | compressed_data: compressed, | ||
| 175 | header_size, | ||
| 176 | _path: path, | ||
| 177 | is_decompressed: deflate.is_done, | ||
| 178 | }) | ||
| 179 | } | ||
| 180 | } | ||
| 181 | |||
| 182 | pub fn parse_header(input: &[u8]) -> Result<(Kind, usize, usize), Error> { | ||
| 183 | let header_end = input | ||
| 184 | .iter() | ||
| 185 | .position(|&b| b == 0) | ||
| 186 | .ok_or_else(|| err_msg("Invalid header, did not find 0 byte"))?; | ||
| 187 | let header = &input[..header_end]; | ||
| 188 | let mut split = header.split(|&b| b == b' '); | ||
| 189 | match (split.next(), split.next()) { | ||
| 190 | (Some(kind), Some(size)) => Ok(( | ||
| 191 | Kind::from_bytes(kind)?, | ||
| 192 | str::from_utf8(size)?.parse()?, | ||
| 193 | header_end + 1, // account for 0 byte | ||
| 194 | )), | ||
| 195 | _ => bail!("expected '<type> <size>'"), | ||
| 196 | } | ||
| 197 | } | ||
| 198 | |||
| 199 | fn sha1_path(id: &[u8; 20], mut root: PathBuf) -> PathBuf { | ||
| 200 | let mut buf = String::with_capacity(40); | ||
| 201 | id.write_hex(&mut buf) | ||
| 202 | .expect("no failure as everything is preset by now"); | ||
| 203 | root.push(&buf[..2]); | ||
| 204 | root.push(&buf[2..]); | ||
| 205 | root | ||
| 206 | } | ||
| 207 | |||
| 208 | pub fn at(path: impl Into<PathBuf>) -> Db { | ||
| 209 | Db { path: path.into() } | ||
| 210 | } | ||
| 211 | } | ||
| 212 | |||
| 213 | pub use self::db::*; | ||
| 214 | pub use self::object::*; | ||
| @@ -1,218 +0,0 @@ | |||
| 1 | use std::str; | ||
| 2 | |||
| 3 | use failure::Error; | ||
| 4 | |||
| 5 | pub type Id = [u8; 20]; | ||
| 6 | |||
| 7 | #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd)] | ||
| 8 | pub enum Kind { | ||
| 9 | Tag, | ||
| 10 | Commit, | ||
| 11 | Tree, | ||
| 12 | Blob, | ||
| 13 | } | ||
| 14 | |||
| 15 | impl Kind { | ||
| 16 | pub fn from_bytes(s: &[u8]) -> Result<Kind, Error> { | ||
| 17 | Ok(match s { | ||
| 18 | b"tag" => Kind::Tag, | ||
| 19 | b"commit" => Kind::Commit, | ||
| 20 | b"tree" => Kind::Tree, | ||
| 21 | b"blob" => Kind::Blob, | ||
| 22 | _ => bail!("Unknown object kind: {:?}", str::from_utf8(s)), | ||
| 23 | }) | ||
| 24 | } | ||
| 25 | } | ||
| 26 | |||
| 27 | pub mod parsed { | ||
| 28 | use failure::{err_msg, Error, ResultExt}; | ||
| 29 | use object::{Id, Kind}; | ||
| 30 | use std::str; | ||
| 31 | use hex::FromHex; | ||
| 32 | use {Sign, Time}; | ||
| 33 | |||
| 34 | const PGP_SIGNATURE_BEGIN: &'static [u8] = b"-----BEGIN PGP SIGNATURE-----"; | ||
| 35 | const PGP_SIGNATURE_END: &'static [u8] = b"-----END PGP SIGNATURE-----"; | ||
| 36 | |||
| 37 | #[derive(PartialEq, Eq, Debug, Hash)] | ||
| 38 | pub enum Object<'data> { | ||
| 39 | Tag(Tag<'data>), | ||
| 40 | } | ||
| 41 | |||
| 42 | impl<'data> Object<'data> { | ||
| 43 | pub fn kind(&self) -> Kind { | ||
| 44 | match self { | ||
| 45 | Object::Tag(_) => Kind::Tag, | ||
| 46 | } | ||
| 47 | } | ||
| 48 | } | ||
| 49 | |||
| 50 | #[derive(PartialEq, Eq, Debug, Hash)] | ||
| 51 | pub struct Signature<'data> { | ||
| 52 | pub name: &'data [u8], | ||
| 53 | pub email: &'data [u8], | ||
| 54 | pub time: Time, | ||
| 55 | } | ||
| 56 | |||
| 57 | #[derive(PartialEq, Eq, Debug, Hash)] | ||
| 58 | pub struct Tag<'data> { | ||
| 59 | pub target_raw: &'data [u8], | ||
| 60 | pub name_raw: &'data [u8], | ||
| 61 | pub target_kind: Kind, | ||
| 62 | pub message: Option<&'data [u8]>, | ||
| 63 | pub pgp_signature: Option<&'data [u8]>, | ||
| 64 | pub signature: Signature<'data>, | ||
| 65 | } | ||
| 66 | |||
| 67 | fn split2_at_space( | ||
| 68 | d: &[u8], | ||
| 69 | v: impl FnOnce(&[u8], &[u8]) -> bool, | ||
| 70 | ) -> Result<(&[u8], &[u8]), Error> { | ||
| 71 | let mut t = d.splitn(2, |&b| b == b' '); | ||
| 72 | Ok(match (t.next(), t.next()) { | ||
| 73 | (Some(t1), Some(t2)) => { | ||
| 74 | if !v(t1, t2) { | ||
| 75 | bail!("Tokens in {:?} are invalid", str::from_utf8(d)) | ||
| 76 | } | ||
| 77 | (t1, t2) | ||
| 78 | } | ||
| 79 | _ => bail!( | ||
| 80 | "didnt find two tokens separated by space in {:?}'", | ||
| 81 | str::from_utf8(d) | ||
| 82 | ), | ||
| 83 | }) | ||
| 84 | } | ||
| 85 | |||
| 86 | fn parse_timezone_offset(d: &str) -> Result<(i32, Sign), Error> { | ||
| 87 | let db = d.as_bytes(); | ||
| 88 | if d.len() < 5 || !(db[0] == b'+' || db[0] == b'-') { | ||
| 89 | bail!("Invalid timezone offset: '{}'", d); | ||
| 90 | } | ||
| 91 | let sign = if db[0] == b'-' { | ||
| 92 | Sign::Minus | ||
| 93 | } else { | ||
| 94 | Sign::Plus | ||
| 95 | }; | ||
| 96 | let hours = str::from_utf8(&db[..3]) | ||
| 97 | .expect("valid utf8") | ||
| 98 | .parse::<i32>()?; | ||
| 99 | let minutes = str::from_utf8(&db[3..]) | ||
| 100 | .expect("valid utf8") | ||
| 101 | .parse::<i32>()?; | ||
| 102 | Ok((hours * 3600 + minutes * 60, sign)) | ||
| 103 | } | ||
| 104 | |||
| 105 | fn parse_signature(d: &[u8]) -> Result<Signature, Error> { | ||
| 106 | const ONE_SPACE: usize = 1; | ||
| 107 | let email_begin = d.iter() | ||
| 108 | .position(|&b| b == b'<') | ||
| 109 | .ok_or_else(|| err_msg("Could not find beginning of email marked by '<'")) | ||
| 110 | .and_then(|pos| { | ||
| 111 | if pos == 0 { | ||
| 112 | Err(err_msg("Email found in place of author name")) | ||
| 113 | } else { | ||
| 114 | Ok(pos) | ||
| 115 | } | ||
| 116 | })?; | ||
| 117 | let email_end = email_begin | ||
| 118 | + d.iter() | ||
| 119 | .skip(email_begin) | ||
| 120 | .position(|&b| b == b'>') | ||
| 121 | .ok_or_else(|| err_msg("Could not find end of email marked by '>'")) | ||
| 122 | .and_then(|pos| { | ||
| 123 | if pos >= d.len() - 1 - ONE_SPACE { | ||
| 124 | Err(err_msg("There is no time after email")) | ||
| 125 | } else { | ||
| 126 | Ok(pos) | ||
| 127 | } | ||
| 128 | })?; | ||
| 129 | let (time_in_seconds, tzofz) = split2_at_space(&d[email_end + ONE_SPACE + 1..], |_, _| { | ||
| 130 | true | ||
| 131 | }).and_then(|(t1, t2)| { | ||
| 132 | str::from_utf8(t1) | ||
| 133 | .map_err(Into::into) | ||
| 134 | .and_then(|t1| str::from_utf8(t2).map_err(Into::into).map(|t2| (t1, t2))) | ||
| 135 | }) | ||
| 136 | .with_context(|_| "Could not convert time to utf8, even though it should be ascii")?; | ||
| 137 | let (offset, sign) = parse_timezone_offset(tzofz) | ||
| 138 | .with_context(|_| format!("Timezone parsing failed for '{}'", tzofz))?; | ||
| 139 | |||
| 140 | Ok(Signature { | ||
| 141 | name: &d[..email_begin - ONE_SPACE], | ||
| 142 | email: &d[email_begin + 1..email_end], | ||
| 143 | time: Time { | ||
| 144 | time: time_in_seconds | ||
| 145 | .parse::<u32>() | ||
| 146 | .with_context(|_| format!("Could not parse '{}' to seconds", time_in_seconds))?, | ||
| 147 | offset, | ||
| 148 | sign, | ||
| 149 | }, | ||
| 150 | }) | ||
| 151 | } | ||
| 152 | |||
| 153 | fn parse_message<'data>( | ||
| 154 | d: &'data [u8], | ||
| 155 | mut lines: impl Iterator<Item = &'data [u8]>, | ||
| 156 | ) -> Result<(Option<&'data [u8]>, Option<&'data [u8]>), Error> { | ||
| 157 | Ok(match lines.next() { | ||
| 158 | Some(l) if l.len() == 0 => { | ||
| 159 | let msg_begin = (l.as_ptr().wrapping_offset_from(d.as_ptr()) + 1) as usize; | ||
| 160 | if msg_begin >= d.len() { | ||
| 161 | bail!("Message separator was not followed by message") | ||
| 162 | } | ||
| 163 | let mut msg_end = d.len(); | ||
| 164 | let mut pgp_signature = None; | ||
| 165 | if let Some(pgp_begin_line) = lines.find(|l| l.starts_with(PGP_SIGNATURE_BEGIN)) { | ||
| 166 | match lines.find(|l| l.starts_with(PGP_SIGNATURE_END)) { | ||
| 167 | None => bail!("Didn't find end of signature marker"), | ||
| 168 | Some(_) => { | ||
| 169 | msg_end = | ||
| 170 | pgp_begin_line.as_ptr().wrapping_offset_from(d.as_ptr()) as usize; | ||
| 171 | pgp_signature = Some(&d[msg_end..]) | ||
| 172 | } | ||
| 173 | } | ||
| 174 | } | ||
| 175 | (Some(&d[msg_begin..msg_end]), pgp_signature) | ||
| 176 | } | ||
| 177 | Some(l) => bail!( | ||
| 178 | "Expected empty newline to separate message, got {:?}", | ||
| 179 | str::from_utf8(l), | ||
| 180 | ), | ||
| 181 | None => (None, None), | ||
| 182 | }) | ||
| 183 | } | ||
| 184 | |||
| 185 | impl<'data> Tag<'data> { | ||
| 186 | pub fn target(&self) -> Id { | ||
| 187 | <[u8; 20]>::from_hex(self.target_raw).expect("prior validation") | ||
| 188 | } | ||
| 189 | pub fn from_bytes(d: &'data [u8]) -> Result<Tag<'data>, Error> { | ||
| 190 | let mut lines = d.split(|&b| b == b'\n'); | ||
| 191 | let (target, target_kind, name, signature) = | ||
| 192 | match (lines.next(), lines.next(), lines.next(), lines.next()) { | ||
| 193 | (Some(target), Some(kind), Some(name), Some(tagger)) => { | ||
| 194 | let (_, target) = split2_at_space(target, |f, v| { | ||
| 195 | f == b"object" && v.len() == 40 && <[u8; 20]>::from_hex(v).is_ok() | ||
| 196 | })?; | ||
| 197 | let kind = split2_at_space(kind, |f, _v| f == b"type") | ||
| 198 | .and_then(|(_, kind)| Kind::from_bytes(kind))?; | ||
| 199 | let (_, name) = split2_at_space(name, |f, _v| f == b"tag")?; | ||
| 200 | let (_, tagger) = split2_at_space(tagger, |f, _v| f == b"tagger")?; | ||
| 201 | (target, kind, name, parse_signature(tagger)?) | ||
| 202 | } | ||
| 203 | _ => bail!("Expected four lines: target, type, tag and tagger"), | ||
| 204 | }; | ||
| 205 | |||
| 206 | let (message, pgp_signature) = parse_message(d, &mut lines)?; | ||
| 207 | |||
| 208 | Ok(Tag { | ||
| 209 | target_raw: target, | ||
| 210 | name_raw: name, | ||
| 211 | target_kind, | ||
| 212 | message, | ||
| 213 | signature, | ||
| 214 | pgp_signature, | ||
| 215 | }) | ||
| 216 | } | ||
| 217 | } | ||
| 218 | } | ||
| @@ -0,0 +1,27 @@ | |||
| 1 | use std::str; | ||
| 2 | |||
| 3 | use failure::Error; | ||
| 4 | |||
| 5 | pub type Id = [u8; 20]; | ||
| 6 | |||
| 7 | #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd)] | ||
| 8 | pub enum Kind { | ||
| 9 | Tag, | ||
| 10 | Commit, | ||
| 11 | Tree, | ||
| 12 | Blob, | ||
| 13 | } | ||
| 14 | |||
| 15 | impl Kind { | ||
| 16 | pub fn from_bytes(s: &[u8]) -> Result<Kind, Error> { | ||
| 17 | Ok(match s { | ||
| 18 | b"tag" => Kind::Tag, | ||
| 19 | b"commit" => Kind::Commit, | ||
| 20 | b"tree" => Kind::Tree, | ||
| 21 | b"blob" => Kind::Blob, | ||
| 22 | _ => bail!("Unknown object kind: {:?}", str::from_utf8(s)), | ||
| 23 | }) | ||
| 24 | } | ||
| 25 | } | ||
| 26 | |||
| 27 | pub mod parsed; | ||
| @@ -0,0 +1,188 @@ | |||
| 1 | use failure::{err_msg, Error, ResultExt}; | ||
| 2 | use object::{Id, Kind}; | ||
| 3 | use std::str; | ||
| 4 | use hex::FromHex; | ||
| 5 | use {Sign, Time}; | ||
| 6 | |||
| 7 | const PGP_SIGNATURE_BEGIN: &'static [u8] = b"-----BEGIN PGP SIGNATURE-----"; | ||
| 8 | const PGP_SIGNATURE_END: &'static [u8] = b"-----END PGP SIGNATURE-----"; | ||
| 9 | |||
| 10 | #[derive(PartialEq, Eq, Debug, Hash)] | ||
| 11 | pub enum Object<'data> { | ||
| 12 | Tag(Tag<'data>), | ||
| 13 | } | ||
| 14 | |||
| 15 | impl<'data> Object<'data> { | ||
| 16 | pub fn kind(&self) -> Kind { | ||
| 17 | match self { | ||
| 18 | Object::Tag(_) => Kind::Tag, | ||
| 19 | } | ||
| 20 | } | ||
| 21 | } | ||
| 22 | |||
| 23 | #[derive(PartialEq, Eq, Debug, Hash)] | ||
| 24 | pub struct Signature<'data> { | ||
| 25 | pub name: &'data [u8], | ||
| 26 | pub email: &'data [u8], | ||
| 27 | pub time: Time, | ||
| 28 | } | ||
| 29 | |||
| 30 | #[derive(PartialEq, Eq, Debug, Hash)] | ||
| 31 | pub struct Tag<'data> { | ||
| 32 | pub target_raw: &'data [u8], | ||
| 33 | pub name_raw: &'data [u8], | ||
| 34 | pub target_kind: Kind, | ||
| 35 | pub message: Option<&'data [u8]>, | ||
| 36 | pub pgp_signature: Option<&'data [u8]>, | ||
| 37 | pub signature: Signature<'data>, | ||
| 38 | } | ||
| 39 | |||
| 40 | fn split2_at_space( | ||
| 41 | d: &[u8], | ||
| 42 | v: impl FnOnce(&[u8], &[u8]) -> bool, | ||
| 43 | ) -> Result<(&[u8], &[u8]), Error> { | ||
| 44 | let mut t = d.splitn(2, |&b| b == b' '); | ||
| 45 | Ok(match (t.next(), t.next()) { | ||
| 46 | (Some(t1), Some(t2)) => { | ||
| 47 | if !v(t1, t2) { | ||
| 48 | bail!("Tokens in {:?} are invalid", str::from_utf8(d)) | ||
| 49 | } | ||
| 50 | (t1, t2) | ||
| 51 | } | ||
| 52 | _ => bail!( | ||
| 53 | "didnt find two tokens separated by space in {:?}'", | ||
| 54 | str::from_utf8(d) | ||
| 55 | ), | ||
| 56 | }) | ||
| 57 | } | ||
| 58 | |||
| 59 | fn parse_timezone_offset(d: &str) -> Result<(i32, Sign), Error> { | ||
| 60 | let db = d.as_bytes(); | ||
| 61 | if d.len() < 5 || !(db[0] == b'+' || db[0] == b'-') { | ||
| 62 | bail!("Invalid timezone offset: '{}'", d); | ||
| 63 | } | ||
| 64 | let sign = if db[0] == b'-' { | ||
| 65 | Sign::Minus | ||
| 66 | } else { | ||
| 67 | Sign::Plus | ||
| 68 | }; | ||
| 69 | let hours = str::from_utf8(&db[..3]) | ||
| 70 | .expect("valid utf8") | ||
| 71 | .parse::<i32>()?; | ||
| 72 | let minutes = str::from_utf8(&db[3..]) | ||
| 73 | .expect("valid utf8") | ||
| 74 | .parse::<i32>()?; | ||
| 75 | Ok((hours * 3600 + minutes * 60, sign)) | ||
| 76 | } | ||
| 77 | |||
| 78 | fn parse_signature(d: &[u8]) -> Result<Signature, Error> { | ||
| 79 | const ONE_SPACE: usize = 1; | ||
| 80 | let email_begin = d.iter() | ||
| 81 | .position(|&b| b == b'<') | ||
| 82 | .ok_or_else(|| err_msg("Could not find beginning of email marked by '<'")) | ||
| 83 | .and_then(|pos| { | ||
| 84 | if pos == 0 { | ||
| 85 | Err(err_msg("Email found in place of author name")) | ||
| 86 | } else { | ||
| 87 | Ok(pos) | ||
| 88 | } | ||
| 89 | })?; | ||
| 90 | let email_end = email_begin | ||
| 91 | + d.iter() | ||
| 92 | .skip(email_begin) | ||
| 93 | .position(|&b| b == b'>') | ||
| 94 | .ok_or_else(|| err_msg("Could not find end of email marked by '>'")) | ||
| 95 | .and_then(|pos| { | ||
| 96 | if pos >= d.len() - 1 - ONE_SPACE { | ||
| 97 | Err(err_msg("There is no time after email")) | ||
| 98 | } else { | ||
| 99 | Ok(pos) | ||
| 100 | } | ||
| 101 | })?; | ||
| 102 | let (time_in_seconds, tzofz) = split2_at_space(&d[email_end + ONE_SPACE + 1..], |_, _| true) | ||
| 103 | .and_then(|(t1, t2)| { | ||
| 104 | str::from_utf8(t1) | ||
| 105 | .map_err(Into::into) | ||
| 106 | .and_then(|t1| str::from_utf8(t2).map_err(Into::into).map(|t2| (t1, t2))) | ||
| 107 | }) | ||
| 108 | .with_context(|_| "Could not convert time to utf8, even though it should be ascii")?; | ||
| 109 | let (offset, sign) = parse_timezone_offset(tzofz) | ||
| 110 | .with_context(|_| format!("Timezone parsing failed for '{}'", tzofz))?; | ||
| 111 | |||
| 112 | Ok(Signature { | ||
| 113 | name: &d[..email_begin - ONE_SPACE], | ||
| 114 | email: &d[email_begin + 1..email_end], | ||
| 115 | time: Time { | ||
| 116 | time: time_in_seconds | ||
| 117 | .parse::<u32>() | ||
| 118 | .with_context(|_| format!("Could not parse '{}' to seconds", time_in_seconds))?, | ||
| 119 | offset, | ||
| 120 | sign, | ||
| 121 | }, | ||
| 122 | }) | ||
| 123 | } | ||
| 124 | |||
| 125 | fn parse_message<'data>( | ||
| 126 | d: &'data [u8], | ||
| 127 | mut lines: impl Iterator<Item = &'data [u8]>, | ||
| 128 | ) -> Result<(Option<&'data [u8]>, Option<&'data [u8]>), Error> { | ||
| 129 | Ok(match lines.next() { | ||
| 130 | Some(l) if l.len() == 0 => { | ||
| 131 | let msg_begin = (l.as_ptr().wrapping_offset_from(d.as_ptr()) + 1) as usize; | ||
| 132 | if msg_begin >= d.len() { | ||
| 133 | bail!("Message separator was not followed by message") | ||
| 134 | } | ||
| 135 | let mut msg_end = d.len(); | ||
| 136 | let mut pgp_signature = None; | ||
| 137 | if let Some(pgp_begin_line) = lines.find(|l| l.starts_with(PGP_SIGNATURE_BEGIN)) { | ||
| 138 | match lines.find(|l| l.starts_with(PGP_SIGNATURE_END)) { | ||
| 139 | None => bail!("Didn't find end of signature marker"), | ||
| 140 | Some(_) => { | ||
| 141 | msg_end = pgp_begin_line.as_ptr().wrapping_offset_from(d.as_ptr()) as usize; | ||
| 142 | pgp_signature = Some(&d[msg_end..]) | ||
| 143 | } | ||
| 144 | } | ||
| 145 | } | ||
| 146 | (Some(&d[msg_begin..msg_end]), pgp_signature) | ||
| 147 | } | ||
| 148 | Some(l) => bail!( | ||
| 149 | "Expected empty newline to separate message, got {:?}", | ||
| 150 | str::from_utf8(l), | ||
| 151 | ), | ||
| 152 | None => (None, None), | ||
| 153 | }) | ||
| 154 | } | ||
| 155 | |||
| 156 | impl<'data> Tag<'data> { | ||
| 157 | pub fn target(&self) -> Id { | ||
| 158 | <[u8; 20]>::from_hex(self.target_raw).expect("prior validation") | ||
| 159 | } | ||
| 160 | pub fn from_bytes(d: &'data [u8]) -> Result<Tag<'data>, Error> { | ||
| 161 | let mut lines = d.split(|&b| b == b'\n'); | ||
| 162 | let (target, target_kind, name, signature) = | ||
| 163 | match (lines.next(), lines.next(), lines.next(), lines.next()) { | ||
| 164 | (Some(target), Some(kind), Some(name), Some(tagger)) => { | ||
| 165 | let (_, target) = split2_at_space(target, |f, v| { | ||
| 166 | f == b"object" && v.len() == 40 && <[u8; 20]>::from_hex(v).is_ok() | ||
| 167 | })?; | ||
| 168 | let kind = split2_at_space(kind, |f, _v| f == b"type") | ||
| 169 | .and_then(|(_, kind)| Kind::from_bytes(kind))?; | ||
| 170 | let (_, name) = split2_at_space(name, |f, _v| f == b"tag")?; | ||
| 171 | let (_, tagger) = split2_at_space(tagger, |f, _v| f == b"tagger")?; | ||
| 172 | (target, kind, name, parse_signature(tagger)?) | ||
| 173 | } | ||
| 174 | _ => bail!("Expected four lines: target, type, tag and tagger"), | ||
| 175 | }; | ||
| 176 | |||
| 177 | let (message, pgp_signature) = parse_message(d, &mut lines)?; | ||
| 178 | |||
| 179 | Ok(Tag { | ||
| 180 | target_raw: target, | ||
| 181 | name_raw: name, | ||
| 182 | target_kind, | ||
| 183 | message, | ||
| 184 | signature, | ||
| 185 | pgp_signature, | ||
| 186 | }) | ||
| 187 | } | ||
| 188 | } | ||