749 lines
24 KiB
Rust
749 lines
24 KiB
Rust
//! Types and constants for DNS TYPes
|
|
|
|
use bytes::Bytes;
|
|
use crate::errors::*;
|
|
use crate::records::registry::{lookup_type_to_name, lookup_type_name};
|
|
use crate::ser::packet::{DnsPacketData, DnsPacketWriteContext};
|
|
use crate::ser::text::{DnsTextData, DnsTextFormatter, DnsTextContext, next_field};
|
|
use std::borrow::Cow;
|
|
use std::fmt;
|
|
use std::io::Cursor;
|
|
|
|
/// a host address
|
|
pub const A : Type = Type(KnownType::A as u16);
|
|
/// an authoritative name server
|
|
pub const NS : Type = Type(KnownType::NS as u16);
|
|
/// a mail destination (OBSOLETE - use MX)
|
|
pub const MD : Type = Type(KnownType::MD as u16);
|
|
/// a mail forwarder (OBSOLETE - use MX)
|
|
pub const MF : Type = Type(KnownType::MF as u16);
|
|
/// the canonical name for an alias
|
|
pub const CNAME : Type = Type(KnownType::CNAME as u16);
|
|
/// marks the start of a zone of authority
|
|
pub const SOA : Type = Type(KnownType::SOA as u16);
|
|
/// a mailbox domain name (EXPERIMENTAL)
|
|
pub const MB : Type = Type(KnownType::MB as u16);
|
|
/// a mail group member (EXPERIMENTAL)
|
|
pub const MG : Type = Type(KnownType::MG as u16);
|
|
/// a mail rename domain name (EXPERIMENTAL)
|
|
pub const MR : Type = Type(KnownType::MR as u16);
|
|
/// a null RR (EXPERIMENTAL)
|
|
pub const NULL : Type = Type(KnownType::NULL as u16);
|
|
/// a well known service description
|
|
pub const WKS : Type = Type(KnownType::WKS as u16);
|
|
/// a domain name pointer
|
|
pub const PTR : Type = Type(KnownType::PTR as u16);
|
|
/// host information
|
|
pub const HINFO : Type = Type(KnownType::HINFO as u16);
|
|
/// mailbox or mail list information
|
|
pub const MINFO : Type = Type(KnownType::MINFO as u16);
|
|
/// mail exchange
|
|
pub const MX : Type = Type(KnownType::MX as u16);
|
|
/// text strings
|
|
pub const TXT : Type = Type(KnownType::TXT as u16);
|
|
/// for Responsible Person
|
|
pub const RP : Type = Type(KnownType::RP as u16);
|
|
/// for AFS Data Base location
|
|
pub const AFSDB : Type = Type(KnownType::AFSDB as u16);
|
|
/// for X.25 PSDN address
|
|
pub const X25 : Type = Type(KnownType::X25 as u16);
|
|
/// for ISDN address
|
|
pub const ISDN : Type = Type(KnownType::ISDN as u16);
|
|
/// for Route Through
|
|
pub const RT : Type = Type(KnownType::RT as u16);
|
|
/// for NSAP address, NSAP style A record
|
|
pub const NSAP : Type = Type(KnownType::NSAP as u16);
|
|
/// for domain name pointer, NSAP style
|
|
pub const NSAP_PTR : Type = Type(KnownType::NSAP_PTR as u16);
|
|
/// for security signature
|
|
pub const SIG : Type = Type(KnownType::SIG as u16);
|
|
/// for security key
|
|
pub const KEY : Type = Type(KnownType::KEY as u16);
|
|
/// X.400 mail mapping information
|
|
pub const PX : Type = Type(KnownType::PX as u16);
|
|
/// Geographical Position
|
|
pub const GPOS : Type = Type(KnownType::GPOS as u16);
|
|
/// IP6 Address
|
|
pub const AAAA : Type = Type(KnownType::AAAA as u16);
|
|
/// Location Information
|
|
pub const LOC : Type = Type(KnownType::LOC as u16);
|
|
/// Next Domain (OBSOLETE)
|
|
pub const NXT : Type = Type(KnownType::NXT as u16);
|
|
/// Endpoint Identifier
|
|
pub const EID : Type = Type(KnownType::EID as u16);
|
|
/// Nimrod Locator
|
|
pub const NIMLOC : Type = Type(KnownType::NIMLOC as u16);
|
|
/// Server Selection
|
|
pub const SRV : Type = Type(KnownType::SRV as u16);
|
|
/// ATM Address
|
|
pub const ATMA : Type = Type(KnownType::ATMA as u16);
|
|
/// Naming Authority Pointer
|
|
pub const NAPTR : Type = Type(KnownType::NAPTR as u16);
|
|
/// Key Exchanger
|
|
pub const KX : Type = Type(KnownType::KX as u16);
|
|
/// CERT
|
|
pub const CERT : Type = Type(KnownType::CERT as u16);
|
|
/// A6 (OBSOLETE - use AAAA)
|
|
pub const A6 : Type = Type(KnownType::A6 as u16);
|
|
/// DNAME
|
|
pub const DNAME : Type = Type(KnownType::DNAME as u16);
|
|
/// SINK
|
|
pub const SINK : Type = Type(KnownType::SINK as u16);
|
|
/// OPT
|
|
pub const OPT : Type = Type(KnownMetaType::OPT as u16);
|
|
/// APL
|
|
pub const APL : Type = Type(KnownType::APL as u16);
|
|
/// Delegation Signer
|
|
pub const DS : Type = Type(KnownType::DS as u16);
|
|
/// SSH Key Fingerprint
|
|
pub const SSHFP : Type = Type(KnownType::SSHFP as u16);
|
|
/// IPSECKEY
|
|
pub const IPSECKEY : Type = Type(KnownType::IPSECKEY as u16);
|
|
/// RRSIG
|
|
pub const RRSIG : Type = Type(KnownType::RRSIG as u16);
|
|
/// NSEC
|
|
pub const NSEC : Type = Type(KnownType::NSEC as u16);
|
|
/// DNSKEY
|
|
pub const DNSKEY : Type = Type(KnownType::DNSKEY as u16);
|
|
/// DHCID
|
|
pub const DHCID : Type = Type(KnownType::DHCID as u16);
|
|
/// NSEC3
|
|
pub const NSEC3 : Type = Type(KnownType::NSEC3 as u16);
|
|
/// NSEC3PARAM
|
|
pub const NSEC3PARAM : Type = Type(KnownType::NSEC3PARAM as u16);
|
|
/// TLSA
|
|
pub const TLSA : Type = Type(KnownType::TLSA as u16);
|
|
/// S/MIME cert association
|
|
pub const SMIMEA : Type = Type(KnownType::SMIMEA as u16);
|
|
/// Host Identity Protocol
|
|
pub const HIP : Type = Type(KnownType::HIP as u16);
|
|
/// NINFO
|
|
pub const NINFO : Type = Type(KnownType::NINFO as u16);
|
|
/// RKEY
|
|
pub const RKEY : Type = Type(KnownType::RKEY as u16);
|
|
/// Trust Anchor LINK
|
|
pub const TALINK : Type = Type(KnownType::TALINK as u16);
|
|
/// Child DS
|
|
pub const CDS : Type = Type(KnownType::CDS as u16);
|
|
/// DNSKEY(s) the Child wants reflected in DS
|
|
pub const CDNSKEY : Type = Type(KnownType::CDNSKEY as u16);
|
|
/// OpenPGP Key
|
|
pub const OPENPGPKEY : Type = Type(KnownType::OPENPGPKEY as u16);
|
|
/// Child-To-Parent Synchronization
|
|
pub const CSYNC : Type = Type(KnownType::CSYNC as u16);
|
|
/// message digest for DNS zone
|
|
pub const ZONEMD : Type = Type(KnownType::ZONEMD as u16);
|
|
/// SPF
|
|
pub const SPF : Type = Type(KnownType::SPF as u16);
|
|
/// UINFO
|
|
pub const UINFO : Type = Type(KnownType::UINFO as u16);
|
|
/// UID
|
|
pub const UID : Type = Type(KnownType::UID as u16);
|
|
/// GID
|
|
pub const GID : Type = Type(KnownType::GID as u16);
|
|
/// UNSPEC
|
|
pub const UNSPEC : Type = Type(KnownType::UNSPEC as u16);
|
|
/// NID
|
|
pub const NID : Type = Type(KnownType::NID as u16);
|
|
/// L32
|
|
pub const L32 : Type = Type(KnownType::L32 as u16);
|
|
/// L64
|
|
pub const L64 : Type = Type(KnownType::L64 as u16);
|
|
/// LP
|
|
pub const LP : Type = Type(KnownType::LP as u16);
|
|
/// an EUI-48 address
|
|
pub const EUI48 : Type = Type(KnownType::EUI48 as u16);
|
|
/// an EUI-64 address
|
|
pub const EUI64 : Type = Type(KnownType::EUI64 as u16);
|
|
/// Transaction Key
|
|
pub const TKEY : Type = Type(KnownMetaType::TKEY as u16);
|
|
/// Transaction Signature
|
|
pub const TSIG : Type = Type(KnownMetaType::TSIG as u16);
|
|
/// incremental transfer
|
|
pub const IXFR : Type = Type(KnownQType::IXFR as u16);
|
|
/// transfer of an entire zone
|
|
pub const AXFR : Type = Type(KnownQType::AXFR as u16);
|
|
/// mailbox-related RRs (MB, MG or MR)
|
|
pub const MAILB : Type = Type(KnownQType::MAILB as u16);
|
|
/// mail agent RRs (OBSOLETE - see MX)
|
|
pub const MAILA : Type = Type(KnownQType::MAILA as u16);
|
|
/// "*", a request for all records the server/cache has available
|
|
pub const ANY : Type = Type(KnownQType::ANY as u16);
|
|
/// URI
|
|
pub const URI : Type = Type(KnownType::URI as u16);
|
|
/// Certification Authority Restriction
|
|
pub const CAA : Type = Type(KnownType::CAA as u16);
|
|
/// Application Visibility and Control
|
|
pub const AVC : Type = Type(KnownType::AVC as u16);
|
|
/// Digital Object Architecture
|
|
pub const DOA : Type = Type(KnownType::DOA as u16);
|
|
/// Automatic Multicast Tunneling Relay
|
|
pub const AMTRELAY : Type = Type(KnownType::AMTRELAY as u16);
|
|
/// DNSSEC Trust Authorities
|
|
pub const TA : Type = Type(KnownType::TA as u16);
|
|
/// DNSSEC Lookaside Validation
|
|
pub const DLV : Type = Type(KnownType::DLV as u16);
|
|
/// powerdns feature: authoritate should resolve to A and AAAA
|
|
pub const ALIAS : Type = Type(KnownType::ALIAS as u16);
|
|
|
|
/// known data TYPEs
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
|
#[repr(u16)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum KnownType {
|
|
// try to list "original" rfc
|
|
/// a host address
|
|
A = 0x0001, // RFC 1035
|
|
/// an authoritative name server
|
|
NS = 0x0002, // RFC 1035
|
|
/// a mail destination (OBSOLETE - use MX)
|
|
MD = 0x0003, // RFC 1035
|
|
/// a mail forwarder (OBSOLETE - use MX)
|
|
MF = 0x0004, // RFC 1035
|
|
/// the canonical name for an alias
|
|
CNAME = 0x0005, // RFC 1035
|
|
/// marks the start of a zone of authority
|
|
SOA = 0x0006, // RFC 1035
|
|
/// a mailbox domain name (EXPERIMENTAL)
|
|
MB = 0x0007, // RFC 1035
|
|
/// a mail group member (EXPERIMENTAL)
|
|
MG = 0x0008, // RFC 1035
|
|
/// a mail rename domain name (EXPERIMENTAL)
|
|
MR = 0x0009, // RFC 1035
|
|
/// a null RR (EXPERIMENTAL)
|
|
NULL = 0x000a, // RFC 1035
|
|
/// a well known service description
|
|
WKS = 0x000b, // RFC 1035
|
|
/// a domain name pointer
|
|
PTR = 0x000c, // RFC 1035
|
|
/// host information
|
|
HINFO = 0x000d, // RFC 1035
|
|
/// mailbox or mail list information
|
|
MINFO = 0x000e, // RFC 1035
|
|
/// mail exchange
|
|
MX = 0x000f, // RFC 1035
|
|
/// text strings
|
|
TXT = 0x0010, // RFC 1035
|
|
/// for Responsible Person
|
|
RP = 0x0011, // RFC 1183
|
|
/// for AFS Data Base location
|
|
AFSDB = 0x0012, // RFC 1183
|
|
/// for X.25 PSDN address
|
|
X25 = 0x0013, // RFC 1183
|
|
/// for ISDN address
|
|
ISDN = 0x0014, // RFC 1183
|
|
/// for Route Through
|
|
RT = 0x0015, // RFC 1183
|
|
/// for NSAP address, NSAP style A record
|
|
NSAP = 0x0016, // RFC 1706
|
|
/// for domain name pointer, NSAP style
|
|
NSAP_PTR = 0x0017, // RFC 1348
|
|
/// for security signature
|
|
SIG = 0x0018, // RFC 2535
|
|
/// for security key
|
|
KEY = 0x0019, // RFC 2535
|
|
/// X.400 mail mapping information
|
|
PX = 0x001a, // RFC 2163
|
|
/// Geographical Position
|
|
GPOS = 0x001b, // RFC 1712
|
|
/// IP6 Address
|
|
AAAA = 0x001c, // RFC 3596
|
|
/// Location Information
|
|
LOC = 0x001d, // RFC 1876
|
|
/// Next Domain (OBSOLETE)
|
|
NXT = 0x001e, // RFC 2535
|
|
/// Endpoint Identifier
|
|
EID = 0x001f, // Michael Patton: http://ana-3.lcs.mit.edu/~jnc/nimrod/dns.txt
|
|
/// Nimrod Locator
|
|
NIMLOC = 0x0020, // Michael Patton: http://ana-3.lcs.mit.edu/~jnc/nimrod/dns.txt
|
|
/// Server Selection
|
|
SRV = 0x0021, // RFC 2782
|
|
/// ATM Address
|
|
ATMA = 0x0022, // http://www.broadband-forum.org/ftp/pub/approved-specs/af-dans-0152.000.pdf
|
|
/// Naming Authority Pointer
|
|
NAPTR = 0x0023, // RFC 2168
|
|
/// Key Exchanger
|
|
KX = 0x0024, // RFC 2230
|
|
/// CERT
|
|
CERT = 0x0025, // RFC 4398
|
|
/// A6 (OBSOLETE - use AAAA)
|
|
A6 = 0x0026, // RFC 2874
|
|
/// DNAME
|
|
DNAME = 0x0027, // RFC 6672
|
|
/// SINK
|
|
SINK = 0x0028, // Donald E Eastlake: http://tools.ietf.org/html/draft-eastlake-kitchen-sink
|
|
// OPT (0x0029) is a meta type
|
|
/// APL
|
|
APL = 0x002a, // RFC 3123
|
|
/// Delegation Signer
|
|
DS = 0x002b, // RFC 3658
|
|
/// SSH Key Fingerprint
|
|
SSHFP = 0x002c, // RFC 4255
|
|
/// IPSECKEY
|
|
IPSECKEY = 0x002d, // RFC 4025
|
|
/// RRSIG
|
|
RRSIG = 0x002e, // RFC 4034
|
|
/// NSEC
|
|
NSEC = 0x002f, // RFC 4034
|
|
/// DNSKEY
|
|
DNSKEY = 0x0030, // RFC 4034
|
|
/// DHCID
|
|
DHCID = 0x0031, // RFC 4701
|
|
/// NSEC3
|
|
NSEC3 = 0x0032, // RFC 5155
|
|
/// NSEC3PARAM
|
|
NSEC3PARAM = 0x0033, // RFC 5155
|
|
/// TLSA
|
|
TLSA = 0x0034, // RFC 6698
|
|
/// S/MIME cert association
|
|
SMIMEA = 0x0035, // RFC 8162
|
|
/// Host Identity Protocol
|
|
HIP = 0x0037, // RFC 8005
|
|
/// NINFO
|
|
NINFO = 0x0038, // Jim Reid: https://tools.ietf.org/html/draft-reid-dnsext-zs-01
|
|
/// RKEY
|
|
RKEY = 0x0039, // Jim Reid: https://tools.ietf.org/html/draft-reid-dnsext-rkey-00
|
|
/// Trust Anchor LINK
|
|
TALINK = 0x003a, // Wouter Wijngaards
|
|
/// Child DS
|
|
CDS = 0x003b, // RFC 7344
|
|
/// DNSKEY(s) the Child wants reflected in DS
|
|
CDNSKEY = 0x003c, // RFC 7344
|
|
/// OpenPGP Key
|
|
OPENPGPKEY = 0x003d, // RFC 7929
|
|
/// Child-To-Parent Synchronization
|
|
CSYNC = 0x003e, // RFC 7477
|
|
/// message digest for DNS zone
|
|
ZONEMD = 0x003f, // https://tools.ietf.org/html/draft-ietf-dnsop-dns-zone-digest-00
|
|
|
|
// Unassigned: 0x0040..0x0062
|
|
|
|
/// SPF
|
|
SPF = 0x0063, // RFC 7208
|
|
/// UINFO
|
|
UINFO = 0x0064, // IANA-Reserved
|
|
/// UID
|
|
UID = 0x0065, // IANA-Reserved
|
|
/// GID
|
|
GID = 0x0066, // IANA-Reserved
|
|
/// UNSPEC
|
|
UNSPEC = 0x0067, // IANA-Reserved
|
|
/// NID
|
|
NID = 0x0068, // RFC 6742
|
|
/// L32
|
|
L32 = 0x0069, // RFC 6742
|
|
/// L64
|
|
L64 = 0x006a, // RFC 6742
|
|
/// LP
|
|
LP = 0x006b, // RFC 6742
|
|
/// an EUI-48 address
|
|
EUI48 = 0x006c, // RFC 7043
|
|
/// an EUI-64 address
|
|
EUI64 = 0x006d, // RFC 7043
|
|
|
|
// unassigned: 0x006e..0x007f
|
|
|
|
// 0x0080..0x00ff: meta and qtypes
|
|
|
|
/// URI
|
|
URI = 0x0100, // RFC 7553
|
|
/// Certification Authority Restriction
|
|
CAA = 0x0101, // RFC 6844
|
|
/// Application Visibility and Control
|
|
AVC = 0x0102, // Wolfgang Riedel
|
|
/// Digital Object Architecture
|
|
DOA = 0x0103, // http://www.iana.org/go/draft-durand-doa-over-dns
|
|
/// Automatic Multicast Tunneling Relay
|
|
AMTRELAY = 0x0104, // http://www.iana.org/go/draft-ietf-mboned-driad-amt-discovery
|
|
|
|
// Unassigned: 0x0105..0x7fff
|
|
|
|
/// DNSSEC Trust Authorities
|
|
TA = 0x8000, //
|
|
/// DNSSEC Lookaside Validation
|
|
DLV = 0x8001, // RFC 4431
|
|
|
|
// Unassigned: 0x8002..0xfeff
|
|
// Private use: 0xff00..0xfffe
|
|
|
|
/// powerdns feature: authoritative should resolve to A and AAAA
|
|
ALIAS = 0xff79, // powerdns
|
|
|
|
// Reserved: 0xffff
|
|
}
|
|
|
|
/// known QTYPEs
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
|
#[repr(u16)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum KnownQType {
|
|
// Unassigned 0x0080..0x00f8
|
|
|
|
// 0x00f9..0x00fa: meta type
|
|
|
|
/// incremental transfer
|
|
IXFR = 0x00fb, // RFC 1995
|
|
/// transfer of an entire zone
|
|
AXFR = 0x00fc, // RFC 1035
|
|
/// mailbox-related RRs (MB, MG or MR)
|
|
MAILB = 0x00fd, // RFC 1035
|
|
/// mail agent RRs (OBSOLETE - see MX)
|
|
MAILA = 0x00fe, // RFC 1035
|
|
/// "*", a request for all records the server/cache has available
|
|
ANY = 0x00ff, // RFC 1035
|
|
}
|
|
|
|
/// known Meta-TYPEs
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
|
#[repr(u16)]
|
|
#[allow(non_camel_case_types)]
|
|
pub enum KnownMetaType {
|
|
/// OPT
|
|
OPT = 0x0029, // RFC 6891
|
|
|
|
// Unassigned 0x0080..0x00f8
|
|
|
|
/// Transaction Key
|
|
TKEY = 0x00f9, // RFC 2930
|
|
/// Transaction Signature
|
|
TSIG = 0x00fa, // RFC 2845
|
|
|
|
// 0x00fb..0x00ff: qtype
|
|
}
|
|
|
|
/// DNS (RR)TYPE
|
|
///
|
|
/// Originally QTYPE was a superset of TYPE; RFC 6895 now defines:
|
|
///
|
|
/// > There are three subcategories of RRTYPE numbers: data TYPEs,
|
|
/// > QTYPEs, and Meta-TYPEs.
|
|
///
|
|
/// ## `ANY`
|
|
///
|
|
/// QTYPE 255 ("*") doesn't seem to have an official mnemonic; `ANY` is
|
|
/// used in most tools though.
|
|
///
|
|
/// The `ANY` mnemonic conflicts with the QCLASS `ANY` though; the name
|
|
/// functions for `Class` have `_without_any` variants though.
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
|
pub struct Type(pub u16);
|
|
|
|
impl Type {
|
|
/// whether TYPE is known or reserved to be a QTYPE or a Meta-TYPE.
|
|
///
|
|
/// 0x0080-0x00FF is reserved for QTYPEs and Meta-TYPEs; OPT is a
|
|
/// special Meta-TYPE.
|
|
pub fn is_q_or_meta_type(self) -> bool {
|
|
self == OPT || (self.0 >= 128 && self.0 < 256)
|
|
}
|
|
|
|
/// map to `KnownQType`
|
|
pub fn known_qtype(self) -> Option<KnownQType> {
|
|
Some(match self {
|
|
IXFR => KnownQType::IXFR,
|
|
AXFR => KnownQType::AXFR,
|
|
MAILB => KnownQType::MAILB,
|
|
MAILA => KnownQType::MAILA,
|
|
ANY => KnownQType::ANY,
|
|
_ => return None,
|
|
})
|
|
}
|
|
|
|
/// whether TYPE is known to be a QTYPE
|
|
pub fn is_known_qtype(self) -> bool {
|
|
self.known_qtype().is_some()
|
|
}
|
|
|
|
/// map to `KnownMetaType`
|
|
pub fn known_meta_type(self) -> Option<KnownMetaType> {
|
|
Some(match self {
|
|
OPT => KnownMetaType::OPT,
|
|
TKEY => KnownMetaType::TKEY,
|
|
TSIG => KnownMetaType::TSIG,
|
|
_ => return None,
|
|
})
|
|
}
|
|
|
|
/// whether TYPE is known to be a Meta-TYPE
|
|
pub fn is_known_meta_type(self) -> bool {
|
|
self.known_meta_type().is_some()
|
|
}
|
|
|
|
/// name for TYPE if known
|
|
///
|
|
/// Known TYPEs are represented using their known mnemonic, others
|
|
/// return None.
|
|
pub fn known_name(self) -> Option<&'static str> {
|
|
lookup_type_to_name(self)
|
|
}
|
|
|
|
/// name for TYPE
|
|
///
|
|
/// Known TYPEes are represented using their known mnemonic, others
|
|
/// using the "TYPE..." syntax (RFC 3597).
|
|
pub fn name(self) -> Cow<'static, str> {
|
|
match self.known_name() {
|
|
Some(name) => Cow::Borrowed(name),
|
|
None => Cow::Owned(self.generic_name())
|
|
}
|
|
}
|
|
|
|
/// generic name "TYPE..."
|
|
pub fn generic_name(self) -> String {
|
|
let mut result = String::new();
|
|
self.write_generic_name(&mut result).unwrap();
|
|
result
|
|
}
|
|
|
|
/// directly write generic name "TYPE..." to some target
|
|
pub fn write_generic_name<W: fmt::Write>(self, w: &mut W) -> fmt::Result {
|
|
write!(w, "TYPE{}", self.0)
|
|
}
|
|
|
|
/// parses known names (mnemonics)
|
|
pub fn from_known_name(name: &str) -> Option<Self> {
|
|
lookup_type_name(name)
|
|
}
|
|
|
|
/// parses generic names of the form "TYPE..."
|
|
pub fn from_generic_name(name: &str) -> Option<Self> {
|
|
if name.len() > 4 && name.as_bytes()[0..4].eq_ignore_ascii_case(b"TYPE") {
|
|
name[4..].parse::<u16>().ok().map(Type)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// parses any name (mnemonics and "TYPE...")
|
|
pub fn from_name(name: &str) -> Option<Self> {
|
|
Self::from_generic_name(name).or_else(|| {
|
|
Self::from_known_name(name)
|
|
})
|
|
}
|
|
|
|
/// whether TYPE is defined in RFC 1035
|
|
pub fn is_well_known(self) -> bool {
|
|
// 0x0001 (A) ... 0x0010 (TXT) are defined in RFC 1035
|
|
self.0 >= 0x0001 && self.0 <= 0x0010
|
|
}
|
|
|
|
/// require converting to canonical form for DNSSEC (i.e. names must
|
|
/// be converted to (ASCII) lower case).
|
|
///
|
|
/// For DNSSEC name compression is forbidden too; all compressable
|
|
/// TYPEs are included in the list anyway.
|
|
///
|
|
/// See [RFC 4034 section 6.2][1] (obsoletes RFC 3597). Also
|
|
/// updated by [RFC 6840 section 5.1][2].
|
|
///
|
|
/// [1]: https://tools.ietf.org/html/rfc4034#section-6.2
|
|
/// [2]: https://tools.ietf.org/html/rfc6840#section-5.1
|
|
pub fn use_canonical_names(self) -> bool {
|
|
match self {
|
|
NS => true,
|
|
MD => true,
|
|
MF => true,
|
|
CNAME => true,
|
|
SOA => true,
|
|
MB => true,
|
|
MG => true,
|
|
MR => true,
|
|
PTR => true,
|
|
// HINFO => true, // removed by RFC 6840: doesn't have a name in data
|
|
MINFO => true,
|
|
MX => true,
|
|
// HINFO => true, // removed by RFC 6840: see above, also duplicate
|
|
RP => true,
|
|
AFSDB => true,
|
|
RT => true,
|
|
NSAP_PTR => true, // not listed in the RFCs, but probably should be.
|
|
SIG => true,
|
|
PX => true,
|
|
NXT => true,
|
|
SRV => true, // moved up to match numeric order
|
|
NAPTR => true,
|
|
KX => true,
|
|
// SRV => true, // moved up to match numeric order
|
|
A6 => true, // moved up to match numeric order
|
|
DNAME => true,
|
|
// A6 => true, // moved up to match numeric order
|
|
RRSIG => true,
|
|
// NSEC => true, // removed by RFC 6840
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<KnownType> for Type {
|
|
fn from(value: KnownType) -> Self {
|
|
Type(value as u16)
|
|
}
|
|
}
|
|
|
|
impl From<KnownQType> for Type {
|
|
fn from(value: KnownQType) -> Self {
|
|
Type(value as u16)
|
|
}
|
|
}
|
|
|
|
impl From<KnownMetaType> for Type {
|
|
fn from(value: KnownMetaType) -> Self {
|
|
Type(value as u16)
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Type {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match self.known_name() {
|
|
Some(name) => write!(f, "{}", name),
|
|
None => self.write_generic_name(f),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DnsPacketData for Type {
|
|
fn deserialize(data: &mut Cursor<Bytes>) -> Result<Self> {
|
|
Ok(Type(DnsPacketData::deserialize(data)?))
|
|
}
|
|
|
|
fn serialize(&self, context: &mut DnsPacketWriteContext, packet: &mut Vec<u8>) -> Result<()> {
|
|
self.0.serialize(context, packet)
|
|
}
|
|
}
|
|
|
|
impl DnsTextData for Type {
|
|
fn dns_parse(_context: &DnsTextContext, data: &mut &str) -> Result<Self> {
|
|
let field = next_field(data)?;
|
|
Type::from_name(field).ok_or_else(|| failure::format_err!("unknown TYPE {:?}", field))
|
|
}
|
|
|
|
fn dns_format(&self, f: &mut DnsTextFormatter) -> fmt::Result {
|
|
write!(f, "{}", self)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
macro_rules! check_type {
|
|
($t:ident, $dec:expr) => {
|
|
{
|
|
use $crate::records::registry;
|
|
// compare decimal value
|
|
assert_eq!($t, Type($dec), "wrong decimal value for {}", stringify!($t));
|
|
// make sure it's registered
|
|
assert_eq!(registry::lookup_type_name(stringify!($t)), Some($t), "{} not registered", stringify!($t));
|
|
}
|
|
};
|
|
($t:ident, $dec:expr, $name:expr) => {
|
|
{
|
|
use $crate::records::registry;
|
|
// compare decimal value
|
|
assert_eq!($t, Type($dec), "wrong decimal value for {}", stringify!($t));
|
|
// make sure it's registered
|
|
assert_eq!(registry::lookup_type_name($name), Some($t), "{} not registered as {:?}", stringify!($t), $name);
|
|
}
|
|
};
|
|
}
|
|
|
|
// the IANA registry uses decimal numbers; make sure there were no typos
|
|
// when converting them to hex in the constants above.
|
|
//
|
|
// also checks the registry has the name-to-number mapping.
|
|
#[cfg(test)]
|
|
#[test]
|
|
fn check_types() {
|
|
check_type!(A , 1);
|
|
check_type!(NS , 2);
|
|
check_type!(MD , 3);
|
|
check_type!(MF , 4);
|
|
check_type!(CNAME , 5);
|
|
check_type!(SOA , 6);
|
|
check_type!(MB , 7);
|
|
check_type!(MG , 8);
|
|
check_type!(MR , 9);
|
|
check_type!(NULL , 10);
|
|
check_type!(WKS , 11);
|
|
check_type!(PTR , 12);
|
|
check_type!(HINFO , 13);
|
|
check_type!(MINFO , 14);
|
|
check_type!(MX , 15);
|
|
check_type!(TXT , 16);
|
|
check_type!(RP , 17);
|
|
check_type!(AFSDB , 18);
|
|
check_type!(X25 , 19);
|
|
check_type!(ISDN , 20);
|
|
check_type!(RT , 21);
|
|
check_type!(NSAP , 22);
|
|
check_type!(NSAP_PTR , 23, "NSAP-PTR");
|
|
check_type!(SIG , 24);
|
|
check_type!(KEY , 25);
|
|
check_type!(PX , 26);
|
|
check_type!(GPOS , 27);
|
|
check_type!(AAAA , 28);
|
|
check_type!(LOC , 29);
|
|
check_type!(NXT , 30);
|
|
check_type!(EID , 31);
|
|
check_type!(NIMLOC , 32);
|
|
check_type!(SRV , 33);
|
|
check_type!(ATMA , 34);
|
|
check_type!(NAPTR , 35);
|
|
check_type!(KX , 36);
|
|
check_type!(CERT , 37);
|
|
check_type!(A6 , 38);
|
|
check_type!(DNAME , 39);
|
|
check_type!(SINK , 40);
|
|
check_type!(OPT , 41);
|
|
check_type!(APL , 42);
|
|
check_type!(DS , 43);
|
|
check_type!(SSHFP , 44);
|
|
check_type!(IPSECKEY , 45);
|
|
check_type!(RRSIG , 46);
|
|
check_type!(NSEC , 47);
|
|
check_type!(DNSKEY , 48);
|
|
check_type!(DHCID , 49);
|
|
check_type!(NSEC3 , 50);
|
|
check_type!(NSEC3PARAM, 51);
|
|
check_type!(TLSA , 52);
|
|
check_type!(SMIMEA , 53);
|
|
check_type!(HIP , 55);
|
|
check_type!(NINFO , 56);
|
|
check_type!(RKEY , 57);
|
|
check_type!(TALINK , 58);
|
|
check_type!(CDS , 59);
|
|
check_type!(CDNSKEY , 60);
|
|
check_type!(OPENPGPKEY, 61);
|
|
check_type!(CSYNC , 62);
|
|
check_type!(ZONEMD , 63);
|
|
// Unassigned: 64-98
|
|
check_type!(SPF , 99);
|
|
check_type!(UINFO , 100);
|
|
check_type!(UID , 101);
|
|
check_type!(GID , 102);
|
|
check_type!(UNSPEC , 103);
|
|
check_type!(NID , 104);
|
|
check_type!(L32 , 105);
|
|
check_type!(L64 , 106);
|
|
check_type!(LP , 107);
|
|
check_type!(EUI48 , 108);
|
|
check_type!(EUI64 , 109);
|
|
// Unassigned: 110-248
|
|
check_type!(TKEY , 249);
|
|
check_type!(TSIG , 250);
|
|
check_type!(IXFR , 251);
|
|
check_type!(AXFR , 252);
|
|
check_type!(MAILB , 253);
|
|
check_type!(MAILA , 254);
|
|
check_type!(ANY , 255);
|
|
check_type!(URI , 256);
|
|
check_type!(CAA , 257);
|
|
check_type!(AVC , 258);
|
|
check_type!(DOA , 259);
|
|
check_type!(AMTRELAY , 260);
|
|
// Unassigned: 261-32767
|
|
check_type!(TA , 32768);
|
|
check_type!(DLV , 32769);
|
|
// Unassigned: 32770-65279
|
|
// Private use: 65280-65534
|
|
check_type!(ALIAS , 65401);
|
|
// Reserved: 65535
|
|
}
|