Skip to main content

qualia_core_db/net/dns/
ontology.rs

1//! Zero-Allocation In-Memory DNS Record Types Ontology Registry.
2//!
3//! Exposes a compile-time static ontology defining the characteristics, RFCs,
4//! wire schemas, categories, and lossless QualiaDB storage strategies for all
5//! standard DNS record types (matching `ontologies/dns_record_types.ttl`).
6//!
7//! Conforms to QualiaDB Rule 0-A (zero-heap in hot paths) and Rule 0-B (< 500 lines).
8
9#![allow(dead_code)]
10
11use super::wire::DnsType;
12
13/// Semantic category of the DNS Resource Record.
14#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15pub enum DnsCategory {
16    Address,
17    Routing,
18    Delegation,
19    Security,
20    Service,
21    Information,
22    Pseudo,
23    Experimental,
24}
25
26/// Standards-track status according to IETF / IANA.
27#[derive(Debug, Clone, Copy, PartialEq, Eq)]
28pub enum DnsStatus {
29    Standard,
30    Proposed,
31    Experimental,
32    Historic,
33    Obsolete,
34}
35
36/// Zero-heap QualiaDB storage strategy for this record type.
37#[derive(Debug, Clone, Copy, PartialEq, Eq)]
38pub enum QualiaStorageStrategy {
39    /// Fits losslessly in a single 48-byte Super-Quin (e.g. A, AAAA, MX, SRV, CNAME, NS, PTR).
40    InlineSuperQuin,
41    /// Arbitrary length payload chunked into contiguous 16-byte Super-Quins with ECC parity.
42    LosslessQuinChunkChain,
43}
44
45/// Comprehensive metadata descriptor for a single DNS record type.
46#[derive(Debug, Clone, Copy, PartialEq, Eq)]
47pub struct DnsRecordTypeDescriptor {
48    pub type_code: u16,
49    pub type_name: &'static str,
50    pub defining_rfc: &'static str,
51    pub description: &'static str,
52    pub schema_definition: &'static str,
53    pub category: DnsCategory,
54    pub status: DnsStatus,
55    pub storage_strategy: QualiaStorageStrategy,
56}
57
58impl DnsRecordTypeDescriptor {
59    /// `true` when `lossless_inline`.
60    pub const fn is_lossless_inline(&self) -> bool {
61        matches!(
62            self.storage_strategy,
63            QualiaStorageStrategy::InlineSuperQuin
64        )
65    }
66}
67
68/// Authoritative static table of all standard DNS record types.
69pub static DNS_ONTOLOGY_REGISTRY: &[DnsRecordTypeDescriptor] = &[
70    DnsRecordTypeDescriptor {
71        type_code: 1,
72        type_name: "A",
73        defining_rfc: "RFC 1035",
74        description: "32-bit IPv4 address",
75        schema_definition: "ipv4: [u8; 4]",
76        category: DnsCategory::Address,
77        status: DnsStatus::Standard,
78        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
79    },
80    DnsRecordTypeDescriptor {
81        type_code: 2,
82        type_name: "NS",
83        defining_rfc: "RFC 1035",
84        description: "Authoritative name server for the zone",
85        schema_definition: "nsdname: domain name",
86        category: DnsCategory::Delegation,
87        status: DnsStatus::Standard,
88        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
89    },
90    DnsRecordTypeDescriptor {
91        type_code: 5,
92        type_name: "CNAME",
93        defining_rfc: "RFC 1035",
94        description: "Canonical name for an alias",
95        schema_definition: "cname: domain name",
96        category: DnsCategory::Delegation,
97        status: DnsStatus::Standard,
98        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
99    },
100    DnsRecordTypeDescriptor {
101        type_code: 6,
102        type_name: "SOA",
103        defining_rfc: "RFC 1035",
104        description: "Start of Authority zone parameters",
105        schema_definition: "mname: domain, rname: domain, serial: u32, refresh: u32, retry: u32, expire: u32, minimum: u32",
106        category: DnsCategory::Information,
107        status: DnsStatus::Standard,
108        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
109    },
110    DnsRecordTypeDescriptor {
111        type_code: 12,
112        type_name: "PTR",
113        defining_rfc: "RFC 1035",
114        description: "Pointer to a canonical name (reverse DNS)",
115        schema_definition: "ptrdname: domain name",
116        category: DnsCategory::Delegation,
117        status: DnsStatus::Standard,
118        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
119    },
120    DnsRecordTypeDescriptor {
121        type_code: 13,
122        type_name: "HINFO",
123        defining_rfc: "RFC 8482",
124        description: "Host information (CPU and Operating System)",
125        schema_definition: "cpu: string, os: string",
126        category: DnsCategory::Information,
127        status: DnsStatus::Standard,
128        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
129    },
130    DnsRecordTypeDescriptor {
131        type_code: 15,
132        type_name: "MX",
133        defining_rfc: "RFC 1035, RFC 7505",
134        description: "Mail exchange server preference and host",
135        schema_definition: "preference: u16, exchange: domain name",
136        category: DnsCategory::Routing,
137        status: DnsStatus::Standard,
138        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
139    },
140    DnsRecordTypeDescriptor {
141        type_code: 16,
142        type_name: "TXT",
143        defining_rfc: "RFC 1035",
144        description: "Text strings up to 64KB for machine/human metadata (SPF, DKIM, QDP)",
145        schema_definition: "txt_data: [length-prefixed strings]",
146        category: DnsCategory::Information,
147        status: DnsStatus::Standard,
148        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
149    },
150    DnsRecordTypeDescriptor {
151        type_code: 28,
152        type_name: "AAAA",
153        defining_rfc: "RFC 3596",
154        description: "128-bit IPv6 address",
155        schema_definition: "ipv6: [u8; 16] (lossless object[0..8] + context[8..16])",
156        category: DnsCategory::Address,
157        status: DnsStatus::Standard,
158        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
159    },
160    DnsRecordTypeDescriptor {
161        type_code: 29,
162        type_name: "LOC",
163        defining_rfc: "RFC 1876",
164        description: "Geographic location information (lat, long, altitude)",
165        schema_definition: "version: u8, size: u8, hp: u8, vp: u8, lat: u32, lon: u32, alt: u32",
166        category: DnsCategory::Information,
167        status: DnsStatus::Standard,
168        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
169    },
170    DnsRecordTypeDescriptor {
171        type_code: 33,
172        type_name: "SRV",
173        defining_rfc: "RFC 2782",
174        description: "Generalized service location record",
175        schema_definition: "priority: u16, weight: u16, port: u16, target: domain name",
176        category: DnsCategory::Routing,
177        status: DnsStatus::Standard,
178        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
179    },
180    DnsRecordTypeDescriptor {
181        type_code: 35,
182        type_name: "NAPTR",
183        defining_rfc: "RFC 3403",
184        description: "Naming Authority Pointer for ENUM/SIP regex rewrite",
185        schema_definition: "order: u16, pref: u16, flags: str, services: str, regexp: str, replacement: domain",
186        category: DnsCategory::Routing,
187        status: DnsStatus::Standard,
188        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
189    },
190    DnsRecordTypeDescriptor {
191        type_code: 37,
192        type_name: "CERT",
193        defining_rfc: "RFC 4398",
194        description: "PKIX, SPKI, PGP certificate container",
195        schema_definition: "type: u16, key_tag: u16, algorithm: u8, cert_data: bytes",
196        category: DnsCategory::Information,
197        status: DnsStatus::Standard,
198        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
199    },
200    DnsRecordTypeDescriptor {
201        type_code: 39,
202        type_name: "DNAME",
203        defining_rfc: "RFC 6672",
204        description: "Delegation Name redirect for an entire subtree",
205        schema_definition: "target: domain name",
206        category: DnsCategory::Delegation,
207        status: DnsStatus::Standard,
208        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
209    },
210    DnsRecordTypeDescriptor {
211        type_code: 41,
212        type_name: "OPT",
213        defining_rfc: "RFC 6891",
214        description: "EDNS0 option pseudo-record for extended flags and payload",
215        schema_definition: "udp_payload_size: u16, ext_rcode: u8, version: u8, flags: u16, options: bytes",
216        category: DnsCategory::Pseudo,
217        status: DnsStatus::Standard,
218        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
219    },
220    DnsRecordTypeDescriptor {
221        type_code: 43,
222        type_name: "DS",
223        defining_rfc: "RFC 4034",
224        description: "Delegation Signer pointing to child DNSKEY",
225        schema_definition: "key_tag: u16, algorithm: u8, digest_type: u8, digest: bytes",
226        category: DnsCategory::Security,
227        status: DnsStatus::Standard,
228        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
229    },
230    DnsRecordTypeDescriptor {
231        type_code: 44,
232        type_name: "SSHFP",
233        defining_rfc: "RFC 4255",
234        description: "SSH Public Key Fingerprint",
235        schema_definition: "algorithm: u8, fp_type: u8, fingerprint: bytes",
236        category: DnsCategory::Security,
237        status: DnsStatus::Standard,
238        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
239    },
240    DnsRecordTypeDescriptor {
241        type_code: 45,
242        type_name: "IPSECKEY",
243        defining_rfc: "RFC 4025",
244        description: "IPsec keying material",
245        schema_definition: "precedence: u8, gw_type: u8, algorithm: u8, gateway: bytes, key: bytes",
246        category: DnsCategory::Security,
247        status: DnsStatus::Standard,
248        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
249    },
250    DnsRecordTypeDescriptor {
251        type_code: 46,
252        type_name: "RRSIG",
253        defining_rfc: "RFC 4034",
254        description: "DNSSEC cryptographic signature for an RRSet",
255        schema_definition: "type_covered: u16, alg: u8, labels: u8, orig_ttl: u32, sig_exp: u32, sig_inc: u32, key_tag: u16, signer: domain, sig: bytes",
256        category: DnsCategory::Security,
257        status: DnsStatus::Standard,
258        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
259    },
260    DnsRecordTypeDescriptor {
261        type_code: 47,
262        type_name: "NSEC",
263        defining_rfc: "RFC 4034",
264        description: "Next Secure denial of existence record",
265        schema_definition: "next_domain: domain name, type_bit_maps: bytes",
266        category: DnsCategory::Security,
267        status: DnsStatus::Standard,
268        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
269    },
270    DnsRecordTypeDescriptor {
271        type_code: 48,
272        type_name: "DNSKEY",
273        defining_rfc: "RFC 4034",
274        description: "DNSSEC public signing key",
275        schema_definition: "flags: u16, protocol: u8, algorithm: u8, public_key: bytes",
276        category: DnsCategory::Security,
277        status: DnsStatus::Standard,
278        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
279    },
280    DnsRecordTypeDescriptor {
281        type_code: 50,
282        type_name: "NSEC3",
283        defining_rfc: "RFC 5155",
284        description: "Hashed authenticated denial of existence",
285        schema_definition: "hash_alg: u8, flags: u8, iterations: u16, salt: bytes, next_hashed: bytes, type_bit_maps: bytes",
286        category: DnsCategory::Security,
287        status: DnsStatus::Standard,
288        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
289    },
290    DnsRecordTypeDescriptor {
291        type_code: 51,
292        type_name: "NSEC3PARAM",
293        defining_rfc: "RFC 5155",
294        description: "Parameters for NSEC3 records",
295        schema_definition: "hash_alg: u8, flags: u8, iterations: u16, salt: bytes",
296        category: DnsCategory::Security,
297        status: DnsStatus::Standard,
298        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
299    },
300    DnsRecordTypeDescriptor {
301        type_code: 52,
302        type_name: "TLSA",
303        defining_rfc: "RFC 6698",
304        description: "DANE TLS certificate association",
305        schema_definition: "usage: u8, selector: u8, matching_type: u8, cert_association_data: bytes",
306        category: DnsCategory::Security,
307        status: DnsStatus::Standard,
308        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
309    },
310    DnsRecordTypeDescriptor {
311        type_code: 53,
312        type_name: "SMIMEA",
313        defining_rfc: "RFC 8162",
314        description: "S/MIME certificate association",
315        schema_definition: "usage: u8, selector: u8, matching_type: u8, cert_association_data: bytes",
316        category: DnsCategory::Security,
317        status: DnsStatus::Standard,
318        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
319    },
320    DnsRecordTypeDescriptor {
321        type_code: 59,
322        type_name: "CDS",
323        defining_rfc: "RFC 7344",
324        description: "Child DS for automated delegation signer updates",
325        schema_definition: "key_tag: u16, algorithm: u8, digest_type: u8, digest: bytes",
326        category: DnsCategory::Security,
327        status: DnsStatus::Standard,
328        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
329    },
330    DnsRecordTypeDescriptor {
331        type_code: 60,
332        type_name: "CDNSKEY",
333        defining_rfc: "RFC 7344",
334        description: "Child DNSKEY for automated DNSSEC updates",
335        schema_definition: "flags: u16, protocol: u8, algorithm: u8, public_key: bytes",
336        category: DnsCategory::Security,
337        status: DnsStatus::Standard,
338        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
339    },
340    DnsRecordTypeDescriptor {
341        type_code: 61,
342        type_name: "OPENPGPKEY",
343        defining_rfc: "RFC 7929",
344        description: "OpenPGP public key keyring",
345        schema_definition: "public_keyring: bytes",
346        category: DnsCategory::Security,
347        status: DnsStatus::Standard,
348        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
349    },
350    DnsRecordTypeDescriptor {
351        type_code: 62,
352        type_name: "CSYNC",
353        defining_rfc: "RFC 7477",
354        description: "Child-to-Parent synchronization of records",
355        schema_definition: "serial: u32, flags: u16, type_bit_maps: bytes",
356        category: DnsCategory::Security,
357        status: DnsStatus::Standard,
358        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
359    },
360    DnsRecordTypeDescriptor {
361        type_code: 63,
362        type_name: "ZONEMD",
363        defining_rfc: "RFC 8976",
364        description: "Zone digest for complete zone content verification",
365        schema_definition: "serial: u32, scheme: u8, algorithm: u8, digest: bytes",
366        category: DnsCategory::Security,
367        status: DnsStatus::Standard,
368        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
369    },
370    DnsRecordTypeDescriptor {
371        type_code: 64,
372        type_name: "SVCB",
373        defining_rfc: "RFC 9460",
374        description: "General service binding for transport protocols",
375        schema_definition: "priority: u16, target_name: domain name, svc_params: bytes",
376        category: DnsCategory::Service,
377        status: DnsStatus::Standard,
378        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
379    },
380    DnsRecordTypeDescriptor {
381        type_code: 65,
382        type_name: "HTTPS",
383        defining_rfc: "RFC 9460",
384        description: "Service binding for HTTPS with HTTP/2, HTTP/3, and ECH",
385        schema_definition: "priority: u16, target_name: domain name, svc_params: bytes",
386        category: DnsCategory::Service,
387        status: DnsStatus::Standard,
388        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
389    },
390    DnsRecordTypeDescriptor {
391        type_code: 255,
392        type_name: "ANY",
393        defining_rfc: "RFC 1035, RFC 8482",
394        description: "Meta-query type requesting all available records",
395        schema_definition: "none (query only)",
396        category: DnsCategory::Pseudo,
397        status: DnsStatus::Standard,
398        storage_strategy: QualiaStorageStrategy::InlineSuperQuin,
399    },
400    DnsRecordTypeDescriptor {
401        type_code: 256,
402        type_name: "URI",
403        defining_rfc: "RFC 7553",
404        description: "Publishing mappings from hostnames to URIs",
405        schema_definition: "priority: u16, weight: u16, target: string",
406        category: DnsCategory::Service,
407        status: DnsStatus::Standard,
408        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
409    },
410    DnsRecordTypeDescriptor {
411        type_code: 257,
412        type_name: "CAA",
413        defining_rfc: "RFC 8659",
414        description: "Certification Authority Authorization constraint",
415        schema_definition: "flags: u8, tag: string, value: string",
416        category: DnsCategory::Service,
417        status: DnsStatus::Standard,
418        storage_strategy: QualiaStorageStrategy::LosslessQuinChunkChain,
419    },
420];
421
422/// Look up a DNS record descriptor by its numeric RR type code.
423pub fn lookup_by_code(code: u16) -> Option<&'static DnsRecordTypeDescriptor> {
424    let mut i = 0;
425    while i < DNS_ONTOLOGY_REGISTRY.len() {
426        if DNS_ONTOLOGY_REGISTRY[i].type_code == code {
427            return Some(&DNS_ONTOLOGY_REGISTRY[i]);
428        }
429        i += 1;
430    }
431    None
432}
433
434/// Look up a DNS record descriptor by its mnemonic name (case-insensitive).
435pub fn lookup_by_name(name: &str) -> Option<&'static DnsRecordTypeDescriptor> {
436    let mut i = 0;
437    while i < DNS_ONTOLOGY_REGISTRY.len() {
438        if DNS_ONTOLOGY_REGISTRY[i]
439            .type_name
440            .eq_ignore_ascii_case(name)
441        {
442            return Some(&DNS_ONTOLOGY_REGISTRY[i]);
443        }
444        i += 1;
445    }
446    None
447}
448
449/// Look up descriptor from a typed `DnsType`.
450pub fn lookup_by_dns_type(dtype: DnsType) -> Option<&'static DnsRecordTypeDescriptor> {
451    lookup_by_code(u16::from(dtype))
452}
453
454#[cfg(test)]
455mod tests {
456    use super::*;
457
458    #[test]
459    fn ontology_registry_lookups() {
460        let a_desc = lookup_by_code(1).unwrap();
461        assert_eq!(a_desc.type_name, "A");
462        assert_eq!(a_desc.category, DnsCategory::Address);
463        assert!(a_desc.is_lossless_inline());
464
465        let aaaa_desc = lookup_by_name("aaaa").unwrap();
466        assert_eq!(aaaa_desc.type_code, 28);
467        assert!(aaaa_desc.is_lossless_inline());
468
469        let https_desc = lookup_by_dns_type(DnsType::HTTPS).unwrap();
470        assert_eq!(https_desc.type_code, 65);
471        assert_eq!(
472            https_desc.storage_strategy,
473            QualiaStorageStrategy::LosslessQuinChunkChain
474        );
475
476        assert!(lookup_by_code(9999).is_none());
477        assert!(lookup_by_name("NONEXISTENT").is_none());
478    }
479}