rust-dnsbox/lib/dnsbox-base/src/records/structs.rs

use common_types::*;
use std::net::{Ipv4Addr, Ipv6Addr};

// unless otherwise documented, class should probably be IN (0x0001)

// deriving RRData will add a unit test to make sure the type is
// registered; there must be a records::types::$name `Type` constant
// with the same name as the struct.

#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(IN)]
pub struct A {
	pub addr: Ipv4Addr,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct NS {
	nsdname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct MD {
	madname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct MF {
	madname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct CNAME {
	cname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct SOA {
	mname: DnsCompressedName,
	rname: DnsCompressedName,
	serial: u32,
	refresh: u32,
	retry: u32,
	expire: u32,
	minimum: u32,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct MB {
	madname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct MG {
	mgmname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct MR {
	newname: DnsCompressedName,
}

// not allowed in zone files anyway, i.e. no text representation.
// content not restricted either, just some bytes. no need to parse it,
// generic representation should be just fine.
//
// #[RRClass(ANY)]
// pub struct NULL;

// text representation like: `WKS 127.0.0.1 TCP smtp http 110`. would
// have to parse protocol and service names.
//
// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(IN)]
// pub struct WKS {
//     address: Ipv4Addr,
//     protocol: u8,
//     bitmap: ..., // remaining bytes
// }

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct PTR {
	ptrdname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct HINFO {
	cpu: ShortText,
	os: ShortText,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct MINFO {
	rmailbx: DnsCompressedName,
	emailbx: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct MX {
	preference: u16,
	mxname: DnsCompressedName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct TXT {
	text: LongText,
}

// end of RFC 1035: no DnsCompressedName below!

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct RP {
	mbox: DnsCanonicalName,
	txt: DnsCanonicalName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct AFSDB {
	subtype: u16,
	hostname: DnsCanonicalName,
}

// https://tools.ietf.org/html/rfc1183#section-3.1 says "its format in
// master files is a <character-string>" which say nothing about the
// binary encoding; later it says "<PSDN-address> is a string of decimal
// digits", so it would seem that there is no length encoding or
// restriction.
//
// wireshark and bind use <character-string> though (bind also wants at
// least 4 bytes in the field: probably due to "beginning with the 4
// digit DNIC").
//
// #[RRClass(ANY)]
// pub struct X25 {
//     psdn_address: ShortText,
// }

// #[RRClass(ANY)]
// pub struct ISDN {
//     isdn_address: ShortText,
//     subaddress: Option<ShortText>,
// }

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct RT {
	preference: u16,
	intermediate: DnsCanonicalName,
}

// #[RRClass(ANY)]
// pub struct NSAP;

#[allow(non_camel_case_types)]
#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRTypeName = "NSAP-PTR"]
#[RRClass(ANY)]
pub struct NSAP_PTR {
	owner: DnsCanonicalName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct SIG {
	rr_type: Type,
	algorithm: u8,
	labels: u8,
	// RFC says this can be omitted in text form if it is the same as
	// the TTL on the SIG record. not supported to be omitted here
	// (TODO?).
	original_ttl: OptionalTTL,
	signature_expiration: TimeStrict,
	signature_inception: TimeStrict,
	key_tag: u16,
	signers_name: DnsCanonicalName,
	signature: Base64RemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct KEY {
	flags: u16,
	protocol: u8,
	algorithm: u8,
	public_key: Base64RemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(IN)]
pub struct PX {
	preference: u16,
	map822: DnsCanonicalName,
	mapx400: DnsCanonicalName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)] // not restricted in rfc 1712
pub struct GPOS {
	longitude: ShortText,
	latitude: ShortText,
	altitude: ShortText,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(IN)]
pub struct AAAA {
	addr: Ipv6Addr,
}

pub use super::weird_structs::LOC;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct NXT {
	next: DnsCanonicalName,
	types: NxtTypeBitmap,
}

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct EID;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct NIMLOC;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(IN)]
pub struct SRV {
	preference: u16,
	weight: u16,
	port: u16,
	target: DnsCanonicalName,
}

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct ATMA;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct NAPTR {
	order: u16,
	preference: u16,
	flags: ShortText,
	service: ShortText,
	regexp: ShortText,
	replacement: DnsCanonicalName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(IN)]
pub struct KX {
	preference: u16,
	exchanger: DnsCanonicalName,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
pub struct CERT {
	cert_type: u16,
	key_tag: u16,
	algorithm: u8,
	certificate: Base64RemainingBlob,
}

pub use super::weird_structs::A6;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct DNAME {
	target: DnsCanonicalName,
}

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct SINK;

// OPT should be decoded at "transport level", abuses ttl and class
// fields too.
// pub struct OPT;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct APL;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct DS {
	key_tag: u16,
	algorithm: u8,
	digest_type: u8,
	digest: HexRemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
pub struct SSHFP {
	algorithm: u8,
	fingerprint_type: u8,
	// RFC 4255 doesn't specify whether whitespace is allowed.
	// `HexRemainingBlob` allows whitespace.
	fingerprint: HexRemainingBlob,
}

pub use super::weird_structs::IPSECKEY;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct RRSIG {
	rr_type: Type,
	algorithm: u8,
	labels: u8,
	original_ttl: u32,
	signature_expiration: Time,
	signature_inception: Time,
	key_tag: u16,
	signers_name: DnsCanonicalName,
	signature: Base64RemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct NSEC {
	next: DnsName, // RFC 6840 says not canonic (updates RFC 4034)
	types: NsecTypeBitmap,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct DNSKEY {
	flags: u16,
	protocol: u8,
	algorithm: u8,
	public_key: Base64RemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(IN)]
pub struct DHCID {
	content: Base64RemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct NSEC3 {
	hash_algorithm: u8,
	flags: u8,
	iterations: u16,
	salt: HexShortBlob,
	next_hashed: NextHashedOwnerName,
	types: NsecTypeBitmap,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct NSEC3PARAM {
	hash_algorithm: u8,
	flags: u8,
	iterations: u16,
	salt: HexShortBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct TLSA {
	// TODO: support acronyms from https://tools.ietf.org/html/rfc7218
	cert_usage: u8,
	selector: u8,
	matching_type: u8,
	data: HexRemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct SMIMEA {
	// TODO: support acronyms from https://tools.ietf.org/html/rfc7218
	cert_usage: u8,
	selector: u8,
	matching_type: u8,
	data: HexRemainingBlob,
}

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct HIP;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct NINFO {
	text: LongText,
}


#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct RKEY {
	flags: u16,
	protocol: u8,
	algorithm: u8,
	public_key: Base64RemainingBlob,
}

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct TALINK;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct CDS {
	key_tag: u16,
	algorithm: u8,
	digest_type: u8,
	digest: HexRemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct CDNSKEY {
	flags: u16,
	protocol: u8,
	algorithm: u8,
	public_key: Base64RemainingBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct OPENPGPKEY {
	public_key: Base64RemainingBlob,
}

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct CSYNC;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
pub struct SPF {
	text: LongText,
}

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct UINFO;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct UID;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct GID;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct UNSPEC;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct NID;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct L32;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct L64;

// #[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
// pub struct LP;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct EUI48 {
	addr: EUI48Addr,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct EUI64 {
	addr: EUI64Addr
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct TKEY {
	algorithm: DnsName,
	inception: u32,
	expiration: u32,
	mode: u16,
	error: u16,
	key: Base64LongBlob,
	other: Base64LongBlob,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct TSIG {
	algorithm: DnsName,
	signed: Time48,
	fudge: u16,
	mac: Base64LongBlob,
	original_id: u16,
	error: u16,
	other: Base64LongBlob,
}

// QTYPEs: IXFR, AXFR, MAILB, MAILA, ANY

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct URI {
	priority: u16,
	weight: u16,
	target: UriText,
}

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
// #[RRClass(?)]
pub struct CAA {
	flags: u8,
	tag: UnquotedShortText,
	value: RemainingText,
}

// pub struct AVC;
// pub struct DOA;

#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(ANY)]
pub struct DLV {
	key_tag: u16,
	algorithm: u8,
	digest_type: u8,
	digest: HexRemainingBlob,
}

// powerdns
#[derive(Clone, PartialEq, Eq, Debug, DnsPacketData, DnsTextData, RRData)]
#[RRClass(IN)] // used to lookup A and AAAA - only useful in IN
pub struct ALIAS {
	content: DnsName,
}