116 lines
3.6 KiB
Rust
116 lines
3.6 KiB
Rust
use bytes::Bytes;
|
|
use data_encoding::{self, HEXLOWER_PERMISSIVE};
|
|
use errors::*;
|
|
use failure::{Fail, ResultExt};
|
|
use ser::packet::{DnsPacketData, remaining_bytes, short_blob};
|
|
use ser::text::*;
|
|
use std::fmt;
|
|
use std::io::Cursor;
|
|
|
|
static WHITESPACE: &str = "\t\n\x0c\r "; // \f == \x0c formfeed
|
|
|
|
lazy_static!{
|
|
pub(crate) static ref HEXLOWER_PERMISSIVE_ALLOW_WS: data_encoding::Encoding = {
|
|
let mut spec = data_encoding::Specification::new();
|
|
spec.symbols.push_str("0123456789abcdef");
|
|
spec.translate.from.push_str("ABCDEF");
|
|
spec.translate.to.push_str("abcdef");
|
|
spec.ignore.push_str(WHITESPACE);
|
|
spec.encoding().unwrap()
|
|
};
|
|
|
|
static ref BASE64_ALLOW_WS: data_encoding::Encoding = {
|
|
let mut spec = data_encoding::Specification::new();
|
|
spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
|
|
spec.padding = Some('=');
|
|
spec.ignore.push_str(WHITESPACE);
|
|
spec.encoding().unwrap()
|
|
};
|
|
}
|
|
|
|
// Similar to `ShortText`, but uses (unquoted, no spaces allowed) hex
|
|
// for text representation; "-" when empty
|
|
#[derive(Clone, PartialEq, Eq, Debug)]
|
|
pub struct HexShortBlob(Bytes);
|
|
|
|
impl DnsPacketData for HexShortBlob {
|
|
fn deserialize(data: &mut Cursor<Bytes>) -> Result<Self> {
|
|
Ok(HexShortBlob(short_blob(data)?))
|
|
}
|
|
}
|
|
|
|
impl DnsTextData for HexShortBlob {
|
|
fn dns_parse(_context: &DnsTextContext, data: &mut &str) -> ::errors::Result<Self> {
|
|
let s = next_field(data)?;
|
|
if s == "-" {
|
|
Ok(HexShortBlob(Bytes::new()))
|
|
} else {
|
|
let raw = HEXLOWER_PERMISSIVE.decode(s.as_bytes())
|
|
.with_context(|e| e.context(format!("invalid hex: {:?}", s)))?;
|
|
ensure!(raw.len() < 256, "short hex field must be at most 255 bytes long");
|
|
Ok(HexShortBlob(raw.into()))
|
|
}
|
|
}
|
|
|
|
fn dns_format(&self, f: &mut DnsTextFormatter) -> fmt::Result {
|
|
if self.0.is_empty() {
|
|
write!(f, "-")
|
|
} else {
|
|
write!(f, "{}", HEXLOWER_PERMISSIVE.encode(&self.0))
|
|
}
|
|
}
|
|
}
|
|
|
|
// No length byte (or restriction), just all data to end of record. uses
|
|
// base64 encoding for text representation, whitespace allowed, padding
|
|
// required.
|
|
//
|
|
// No following field allowed, i.e. last field in the record.
|
|
#[derive(Clone, PartialEq, Eq, Debug)]
|
|
pub struct Base64RemainingBlob(Bytes);
|
|
|
|
impl DnsPacketData for Base64RemainingBlob {
|
|
fn deserialize(data: &mut Cursor<Bytes>) -> Result<Self> {
|
|
Ok(Base64RemainingBlob(remaining_bytes(data)))
|
|
}
|
|
}
|
|
|
|
impl DnsTextData for Base64RemainingBlob {
|
|
fn dns_parse(_context: &DnsTextContext, data: &mut &str) -> ::errors::Result<Self> {
|
|
skip_whitespace(data);
|
|
let result = BASE64_ALLOW_WS.decode(data.as_bytes())
|
|
.with_context(|e| e.context(format!("invalid base64: {:?}", data)))?;
|
|
*data = "";
|
|
Ok(Base64RemainingBlob(result.into()))
|
|
}
|
|
|
|
fn dns_format(&self, f: &mut DnsTextFormatter) -> fmt::Result {
|
|
write!(f, "{}", BASE64_ALLOW_WS.encode(&self.0))
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, PartialEq, Eq, Debug)]
|
|
pub struct HexRemainingBlob(Bytes);
|
|
|
|
// No length byte, just all data to end of record. uses hex encoding for
|
|
// text representation (spaces are ignored - last field in record).
|
|
impl DnsPacketData for HexRemainingBlob {
|
|
fn deserialize(data: &mut Cursor<Bytes>) -> Result<Self> {
|
|
Ok(HexRemainingBlob(remaining_bytes(data)))
|
|
}
|
|
}
|
|
|
|
impl DnsTextData for HexRemainingBlob {
|
|
fn dns_parse(_context: &DnsTextContext, data: &mut &str) -> ::errors::Result<Self> {
|
|
skip_whitespace(data);
|
|
let result = HEXLOWER_PERMISSIVE_ALLOW_WS.decode(data.as_bytes())
|
|
.with_context(|e| e.context(format!("invalid hex: {:?}", data)))?;
|
|
*data = "";
|
|
Ok(HexRemainingBlob(result.into()))
|
|
}
|
|
|
|
fn dns_format(&self, f: &mut DnsTextFormatter) -> fmt::Result {
|
|
write!(f, "{}", HEXLOWER_PERMISSIVE_ALLOW_WS.encode(&self.0))
|
|
}
|
|
}
|