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

/*
 * 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::{DecodeError, 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 rustc-serialization,
///  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. rustc-serialization will be used for other coms, e.g. json over http
pub struct BinDecoder<'a> {
  buffer: &'a [u8],
  index: usize,
}

impl<'a> BinDecoder<'a> {
  pub fn new(buffer: &'a [u8]) -> Self {
    BinDecoder { buffer: buffer, index: 0, }
  }

  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(DecodeError::EOF)
    }
  }

  pub fn len(&self) -> usize {
    self.buffer.len() - self.index
  }

  pub fn peek(&self) -> Option<u8> {
    if self.index < self.buffer.len() {
      Some(self.buffer[self.index])
    } else {
      None
    }
  }

  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,
    }
  }

  ///<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).
  ///
  /// the vector should be reversed before calling.
  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...
    Ok(try!(String::from_utf8(label_vec)).to_lowercase())
  }

  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)
  }

  pub fn read_u8(&mut self) -> DecodeResult<u8> {
    self.pop()
  }

  /// parses 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)
  ///
  /// the vector should be reversed before calling.
  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))
  }

  /// parses 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)
  ///
  /// the vector should be reversed before calling.
  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))
  }

  /// parses 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)
  ///
  /// the vector should be reversed before calling.
  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))
  }
}