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
/* * Copyright (C) 2015 Benjamin Fry <benjaminfry@me.com> * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ use error::{DecodeErrorKind, DecodeResult}; /// This is non-destructive to the inner buffer, b/c for pointer types we need to perform a reverse /// seek to lookup names /// /// A note on serialization, there was a thought to have this implement the Serde deserializer, /// but given that this is such a small subset of all the serialization which that performs /// this is a simpler implementation without the cruft, at least for serializing to/from the /// binary DNS protocols. pub struct BinDecoder<'a> { buffer: &'a [u8], index: usize, } impl<'a> BinDecoder<'a> { /// Creates a new BinDecoder /// /// # Arguments /// /// * `buffer` - buffer from which all data will be read pub fn new(buffer: &'a [u8]) -> Self { BinDecoder { buffer: buffer, index: 0, } } /// Pop one byte from the buffer pub fn pop(&mut self) -> DecodeResult<u8> { if self.index < self.buffer.len() { let byte = self.buffer[self.index]; self.index += 1; Ok(byte) } else { Err(DecodeErrorKind::Message("unexpected end of input reached").into()) } } /// Returns the number of bytes in the buffer pub fn len(&self) -> usize { self.buffer.len() - self.index } /// Peed one byte forward, without moving the current index forward pub fn peek(&self) -> Option<u8> { if self.index < self.buffer.len() { Some(self.buffer[self.index]) } else { None } } /// Returns the current index in the buffer pub fn index(&self) -> usize { return self.index; } /// This is a pretty efficient clone, as the buffer is never cloned, and only the index is set /// to the value passed in pub fn clone(&self, index_at: u16) -> BinDecoder { BinDecoder { buffer: self.buffer, index: index_at as usize, } } /// Reads a String from the buffer /// /// ```text /// <character-string> is a single /// length octet followed by that number of characters. <character-string> /// is treated as binary information, and can be up to 256 characters in /// length (including the length octet). /// ``` /// /// # Returns /// /// A String version of the character data pub fn read_character_data(&mut self) -> DecodeResult<String> { let length: u8 = try!(self.pop()); // TODO once Drain stabalizes on Vec, this should be replaced... let label_vec: Vec<u8> = try!(self.read_vec(length as usize)); // translate bytes to string, then lowercase... let data = try!(String::from_utf8(label_vec)); Ok(data) } /// Reads a Vec out of the buffer /// /// # Arguments /// /// * `len` - number of bytes to read from the buffer /// /// # Returns /// /// The Vec of the specified length, otherwise an error pub fn read_vec(&mut self, len: usize) -> DecodeResult<Vec<u8>> { // TODO once Drain stabalizes on Vec, this should be replaced... let mut vec: Vec<u8> = Vec::with_capacity(len); for _ in 0..len as usize { vec.push(try!(self.pop())) } Ok(vec) } /// Reads a byte from the buffer, equivalent to `Self::pop()` pub fn read_u8(&mut self) -> DecodeResult<u8> { self.pop() } /// Reads the next 2 bytes into u16 /// /// This performs a byte-by-byte manipulation, there /// which means endianness is implicitly handled (i.e. no network to little endian (intel), issues) /// /// # Return /// /// Return the u16 from the buffer pub fn read_u16(&mut self) -> DecodeResult<u16> { let b1: u8 = try!(self.pop()); let b2: u8 = try!(self.pop()); // translate from network byte order, i.e. big endian Ok(((b1 as u16) << 8) + (b2 as u16)) } /// Reads the next four bytes into i32. /// /// This performs a byte-by-byte manipulation, there /// which means endianness is implicitly handled (i.e. no network to little endian (intel), issues) /// /// # Return /// /// Return the i32 from the buffer pub fn read_i32(&mut self) -> DecodeResult<i32> { // TODO should this use a default rather than the panic! that will happen in the None case? let b1: u8 = try!(self.pop()); let b2: u8 = try!(self.pop()); let b3: u8 = try!(self.pop()); let b4: u8 = try!(self.pop()); // translate from network byte order, i.e. big endian Ok(((b1 as i32) << 24) + ((b2 as i32) << 16) + ((b3 as i32) << 8) + (b4 as i32)) } /// Reads the next four bytes into u32. /// /// This performs a byte-by-byte manipulation, there /// which means endianness is implicitly handled (i.e. no network to little endian (intel), issues) /// /// # Return /// /// Return the u32 from the buffer pub fn read_u32(&mut self) -> DecodeResult<u32> { // TODO should this use a default rather than the panic! that will happen in the None case? let b1: u8 = try!(self.pop()); let b2: u8 = try!(self.pop()); let b3: u8 = try!(self.pop()); let b4: u8 = try!(self.pop()); // translate from network byte order, i.e. big endian Ok(((b1 as u32) << 24) + ((b2 as u32) << 16) + ((b3 as u32) << 8) + (b4 as u32)) } }