Skip to main content

qualia_core_db/net/dns/
quin_records.rs

1//! QualiaDB Super-Quin (NQuin) DNS and SDN Record Codec.
2//!
3//! Maps standard DNS records and Qualia SDN Front-Door records to 48-byte
4//! `NQuin` statements in QualiaDB's Q42 universe.
5//!
6//! Adheres strictly to QualiaDB Rule 0-A (zero-heap in hot paths) and
7//! Rule 0-B (clean modular decomposition under 500 lines).
8
9#![allow(dead_code)]
10
11use super::wire::{DnsRecordView, DnsType};
12use crate::{q_hash, NQuin, PermissiveRoutingLane};
13
14/// Modality opcodes for DNS in predicate bits [0..7] (Rule 0: all new modalities >= 0x10).
15pub const OP_DNS_A: u8 = 0x50;
16pub const OP_DNS_NS: u8 = 0x51;
17pub const OP_DNS_CNAME: u8 = 0x52;
18pub const OP_DNS_SOA: u8 = 0x53;
19pub const OP_DNS_TXT: u8 = 0x54;
20pub const OP_DNS_AAAA: u8 = 0x55;
21pub const OP_DNS_SRV: u8 = 0x56;
22pub const OP_DNS_CERT: u8 = 0x57;
23pub const OP_DNS_QDP_FRONT_DOOR: u8 = 0x58;
24pub const OP_DNS_SDN_PEER: u8 = 0x59;
25pub const OP_DNS_SDN_ROUTING: u8 = 0x5A;
26pub const OP_DNS_PTR: u8 = 0x5B;
27pub const OP_DNS_MX: u8 = 0x5C;
28pub const OP_DNS_CAA: u8 = 0x5D;
29pub const OP_DNS_TLSA: u8 = 0x5E;
30pub const OP_DNS_HTTPS: u8 = 0x5F;
31pub const OP_DNS_DNSKEY: u8 = 0x60;
32pub const OP_DNS_DS: u8 = 0x61;
33
34/// Inline type tag for integers in object bits [60..62] (resolver.rs authoritative layout).
35pub const INLINE_TAG_INTEGER: u64 = 0b001u64 << 60;
36/// Bit 63 sentinel for did:q42 topological pointer.
37pub const DID_Q42_FLAG: u64 = 1u64 << 63;
38
39/// Default DNS context URI hash.
40pub const DNS_CONTEXT_HASH: u64 = q_hash("qualia:dns:zone");
41
42/// Encode an IPv4 `A` record as an `NQuin`.
43pub fn encode_a_record(
44    domain: &str,
45    ipv4_octets: [u8; 4],
46    ttl: u32,
47    lane: PermissiveRoutingLane,
48) -> NQuin {
49    let subject = q_hash(domain);
50    let pred_hash = q_hash("qualia:dns:a");
51    let predicate = (pred_hash << 8) | (OP_DNS_A as u64);
52    let ip_u32 = u32::from_be_bytes(ipv4_octets) as u64;
53    let object = INLINE_TAG_INTEGER | (ip_u32 & 0x0FFF_FFFF_FFFF_FFFF);
54    let context = DNS_CONTEXT_HASH;
55    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
56    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
57    NQuin {
58        subject,
59        predicate,
60        object,
61        context,
62        metadata,
63        parity,
64    }
65}
66
67/// Decode an `NQuin` into an IPv4 address if it represents an `A` record.
68pub fn decode_a_record(quin: &NQuin) -> Option<([u8; 4], u32, PermissiveRoutingLane)> {
69    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_A {
70        return None;
71    }
72    let tag = quin.object & (0b111u64 << 60);
73    if tag != INLINE_TAG_INTEGER {
74        return None;
75    }
76    let ip_val = (quin.object & 0xFFFF_FFFF) as u32;
77    let octets = ip_val.to_be_bytes();
78    let ttl = (quin.metadata & 0xFFFF_FFFF) as u32;
79    let lane = quin.identify_routing_lane();
80    Some((octets, ttl, lane))
81}
82
83/// Encode an IPv6 `AAAA` record as an `NQuin`.
84///
85/// Losslessly packs all 128 bits:
86/// - `object`: upper 64 bits of IPv6
87/// - `context`: lower 64 bits of IPv6
88pub fn encode_aaaa_record(
89    domain: &str,
90    ipv6_octets: [u8; 16],
91    ttl: u32,
92    lane: PermissiveRoutingLane,
93) -> NQuin {
94    let subject = q_hash(domain);
95    let pred_hash = q_hash("qualia:dns:aaaa");
96    let predicate = (pred_hash << 8) | (OP_DNS_AAAA as u64);
97    let mut hi = [0u8; 8];
98    let mut lo = [0u8; 8];
99    hi.copy_from_slice(&ipv6_octets[0..8]);
100    lo.copy_from_slice(&ipv6_octets[8..16]);
101    let object = u64::from_be_bytes(hi);
102    let context = u64::from_be_bytes(lo);
103    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
104    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
105    NQuin {
106        subject,
107        predicate,
108        object,
109        context,
110        metadata,
111        parity,
112    }
113}
114
115/// Decode an `NQuin` into an IPv6 address if it represents an `AAAA` record.
116pub fn decode_aaaa_record(quin: &NQuin) -> Option<([u8; 16], u32, PermissiveRoutingLane)> {
117    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_AAAA {
118        return None;
119    }
120    let mut ip = [0u8; 16];
121    ip[0..8].copy_from_slice(&quin.object.to_be_bytes());
122    ip[8..16].copy_from_slice(&quin.context.to_be_bytes());
123    let ttl = (quin.metadata & 0xFFFF_FFFF) as u32;
124    let lane = quin.identify_routing_lane();
125    Some((ip, ttl, lane))
126}
127
128/// Encode a `CNAME` record as an `NQuin`.
129pub fn encode_cname_record(
130    domain: &str,
131    target: &str,
132    ttl: u32,
133    lane: PermissiveRoutingLane,
134) -> NQuin {
135    let subject = q_hash(domain);
136    let pred_hash = q_hash("qualia:dns:cname");
137    let predicate = (pred_hash << 8) | (OP_DNS_CNAME as u64);
138    let object = q_hash(target);
139    let context = DNS_CONTEXT_HASH;
140    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
141    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
142    NQuin {
143        subject,
144        predicate,
145        object,
146        context,
147        metadata,
148        parity,
149    }
150}
151
152/// Decode a `CNAME` record `(target_hash, ttl, lane)` from an `NQuin`.
153pub fn decode_cname_record(quin: &NQuin) -> Option<(u64, u32, PermissiveRoutingLane)> {
154    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_CNAME {
155        return None;
156    }
157    Some((
158        quin.object,
159        (quin.metadata & 0xFFFF_FFFF) as u32,
160        quin.identify_routing_lane(),
161    ))
162}
163
164/// Encode an `NS` record as an `NQuin`.
165pub fn encode_ns_record(domain: &str, ns: &str, ttl: u32, lane: PermissiveRoutingLane) -> NQuin {
166    let subject = q_hash(domain);
167    let pred_hash = q_hash("qualia:dns:ns");
168    let predicate = (pred_hash << 8) | (OP_DNS_NS as u64);
169    let object = q_hash(ns);
170    let context = DNS_CONTEXT_HASH;
171    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
172    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
173    NQuin {
174        subject,
175        predicate,
176        object,
177        context,
178        metadata,
179        parity,
180    }
181}
182
183/// Decode an `NS` record `(ns_hash, ttl, lane)` from an `NQuin`.
184pub fn decode_ns_record(quin: &NQuin) -> Option<(u64, u32, PermissiveRoutingLane)> {
185    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_NS {
186        return None;
187    }
188    Some((
189        quin.object,
190        (quin.metadata & 0xFFFF_FFFF) as u32,
191        quin.identify_routing_lane(),
192    ))
193}
194
195/// Encode a `PTR` record as an `NQuin`.
196pub fn encode_ptr_record(
197    rev_domain: &str,
198    target: &str,
199    ttl: u32,
200    lane: PermissiveRoutingLane,
201) -> NQuin {
202    let subject = q_hash(rev_domain);
203    let pred_hash = q_hash("qualia:dns:ptr");
204    let predicate = (pred_hash << 8) | (OP_DNS_PTR as u64);
205    let object = q_hash(target);
206    let context = DNS_CONTEXT_HASH;
207    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
208    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
209    NQuin {
210        subject,
211        predicate,
212        object,
213        context,
214        metadata,
215        parity,
216    }
217}
218
219/// Decode a `PTR` record `(target_hash, ttl, lane)` from an `NQuin`.
220pub fn decode_ptr_record(quin: &NQuin) -> Option<(u64, u32, PermissiveRoutingLane)> {
221    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_PTR {
222        return None;
223    }
224    Some((
225        quin.object,
226        (quin.metadata & 0xFFFF_FFFF) as u32,
227        quin.identify_routing_lane(),
228    ))
229}
230
231/// Encode an `MX` record as an `NQuin`.
232/// `object` packs `(preference << 48) | (exchange_hash & 0x0000_FFFF_FFFF_FFFF)`.
233pub fn encode_mx_record(
234    domain: &str,
235    preference: u16,
236    exchange: &str,
237    ttl: u32,
238    lane: PermissiveRoutingLane,
239) -> NQuin {
240    let subject = q_hash(domain);
241    let pred_hash = q_hash("qualia:dns:mx");
242    let predicate = (pred_hash << 8) | (OP_DNS_MX as u64);
243    let object = ((preference as u64) << 48) | (q_hash(exchange) & 0x0000_FFFF_FFFF_FFFF);
244    let context = DNS_CONTEXT_HASH;
245    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
246    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
247    NQuin {
248        subject,
249        predicate,
250        object,
251        context,
252        metadata,
253        parity,
254    }
255}
256
257/// Decode an `MX` record `(preference, exchange_hash, ttl, lane)` from an `NQuin`.
258pub fn decode_mx_record(quin: &NQuin) -> Option<(u16, u64, u32, PermissiveRoutingLane)> {
259    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_MX {
260        return None;
261    }
262    let preference = (quin.object >> 48) as u16;
263    let exchange_hash = quin.object & 0x0000_FFFF_FFFF_FFFF;
264    Some((
265        preference,
266        exchange_hash,
267        (quin.metadata & 0xFFFF_FFFF) as u32,
268        quin.identify_routing_lane(),
269    ))
270}
271
272/// Encode a `SOA` record as an `NQuin`.
273pub fn encode_soa_record(
274    domain: &str,
275    mname: &str,
276    rname: &str,
277    serial: u32,
278    ttl: u32,
279    lane: PermissiveRoutingLane,
280) -> NQuin {
281    let subject = q_hash(domain);
282    let pred_hash = q_hash("qualia:dns:soa");
283    let predicate = (pred_hash << 8) | (OP_DNS_SOA as u64);
284    let object = ((serial as u64) << 32) | (q_hash(mname) & 0xFFFF_FFFF);
285    let context = q_hash(rname);
286    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
287    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
288    NQuin {
289        subject,
290        predicate,
291        object,
292        context,
293        metadata,
294        parity,
295    }
296}
297
298/// Decode a `SOA` record `(serial, mname_hash, rname_hash, ttl, lane)` from an `NQuin`.
299pub fn decode_soa_record(quin: &NQuin) -> Option<(u32, u64, u64, u32, PermissiveRoutingLane)> {
300    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_SOA {
301        return None;
302    }
303    let serial = (quin.object >> 32) as u32;
304    let mname_hash = quin.object & 0xFFFF_FFFF;
305    let rname_hash = quin.context;
306    Some((
307        serial,
308        mname_hash,
309        rname_hash,
310        (quin.metadata & 0xFFFF_FFFF) as u32,
311        quin.identify_routing_lane(),
312    ))
313}
314
315/// Encode an `SRV` record as an `NQuin`.
316pub fn encode_srv_record(
317    domain: &str,
318    priority: u16,
319    weight: u16,
320    port: u16,
321    target: &str,
322    ttl: u32,
323    lane: PermissiveRoutingLane,
324) -> NQuin {
325    let subject = q_hash(domain);
326    let pred_hash = q_hash("qualia:dns:srv");
327    let predicate = (pred_hash << 8) | (OP_DNS_SRV as u64);
328    let object = ((priority as u64) << 32) | ((weight as u64) << 16) | (port as u64);
329    let context = q_hash(target);
330    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
331    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
332    NQuin {
333        subject,
334        predicate,
335        object,
336        context,
337        metadata,
338        parity,
339    }
340}
341
342/// Decode an `SRV` record `(priority, weight, port, target_hash, ttl, lane)` from an `NQuin`.
343pub fn decode_srv_record(quin: &NQuin) -> Option<(u16, u16, u16, u64, u32, PermissiveRoutingLane)> {
344    if !quin.verify_ecc_parity() || (quin.predicate & 0xFF) as u8 != OP_DNS_SRV {
345        return None;
346    }
347    let priority = (quin.object >> 32) as u16;
348    let weight = (quin.object >> 16) as u16;
349    let port = (quin.object & 0xFFFF) as u16;
350    let target_hash = quin.context;
351    Some((
352        priority,
353        weight,
354        port,
355        target_hash,
356        (quin.metadata & 0xFFFF_FFFF) as u32,
357        quin.identify_routing_lane(),
358    ))
359}
360
361/// Encode a `CAA` record as an `NQuin`.
362pub fn encode_caa_record(
363    domain: &str,
364    flags: u8,
365    tag: &str,
366    value: &str,
367    ttl: u32,
368    lane: PermissiveRoutingLane,
369) -> NQuin {
370    let subject = q_hash(domain);
371    let pred_hash = q_hash("qualia:dns:caa");
372    let predicate = (pred_hash << 8) | (OP_DNS_CAA as u64);
373    let object = ((flags as u64) << 56) | (q_hash(tag) & 0x00FF_FFFF_FFFF_FFFF);
374    let context = q_hash(value);
375    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
376    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
377    NQuin {
378        subject,
379        predicate,
380        object,
381        context,
382        metadata,
383        parity,
384    }
385}
386
387/// Encode a `TLSA` record as an `NQuin`.
388pub fn encode_tlsa_record(
389    domain: &str,
390    usage: u8,
391    selector: u8,
392    matching_type: u8,
393    cert_hash: u64,
394    ttl: u32,
395    lane: PermissiveRoutingLane,
396) -> NQuin {
397    let subject = q_hash(domain);
398    let pred_hash = q_hash("qualia:dns:tlsa");
399    let predicate = (pred_hash << 8) | (OP_DNS_TLSA as u64);
400    let object = ((usage as u64) << 56)
401        | ((selector as u64) << 48)
402        | ((matching_type as u64) << 40)
403        | (cert_hash & 0x0000_00FF_FFFF_FFFF);
404    let context = cert_hash;
405    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
406    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
407    NQuin {
408        subject,
409        predicate,
410        object,
411        context,
412        metadata,
413        parity,
414    }
415}
416
417/// Encode an `HTTPS` / `SVCB` record as an `NQuin`.
418pub fn encode_https_record(
419    domain: &str,
420    priority: u16,
421    target: &str,
422    params_hash: u64,
423    ttl: u32,
424    lane: PermissiveRoutingLane,
425) -> NQuin {
426    let subject = q_hash(domain);
427    let pred_hash = q_hash("qualia:dns:https");
428    let predicate = (pred_hash << 8) | (OP_DNS_HTTPS as u64);
429    let object = ((priority as u64) << 48) | (q_hash(target) & 0x0000_FFFF_FFFF_FFFF);
430    let context = params_hash;
431    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
432    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
433    NQuin {
434        subject,
435        predicate,
436        object,
437        context,
438        metadata,
439        parity,
440    }
441}
442
443/// Encode a `DNSKEY` record as an `NQuin`.
444pub fn encode_dnskey_record(
445    domain: &str,
446    flags: u16,
447    protocol: u8,
448    algorithm: u8,
449    key_hash: u64,
450    ttl: u32,
451    lane: PermissiveRoutingLane,
452) -> NQuin {
453    let subject = q_hash(domain);
454    let pred_hash = q_hash("qualia:dns:dnskey");
455    let predicate = (pred_hash << 8) | (OP_DNS_DNSKEY as u64);
456    let object = ((flags as u64) << 48)
457        | ((protocol as u64) << 40)
458        | ((algorithm as u64) << 32)
459        | (key_hash & 0xFFFF_FFFF);
460    let context = key_hash;
461    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
462    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
463    NQuin {
464        subject,
465        predicate,
466        object,
467        context,
468        metadata,
469        parity,
470    }
471}
472
473/// Encode a `DS` record as an `NQuin`.
474pub fn encode_ds_record(
475    domain: &str,
476    key_tag: u16,
477    algorithm: u8,
478    digest_type: u8,
479    digest_hash: u64,
480    ttl: u32,
481    lane: PermissiveRoutingLane,
482) -> NQuin {
483    let subject = q_hash(domain);
484    let pred_hash = q_hash("qualia:dns:ds");
485    let predicate = (pred_hash << 8) | (OP_DNS_DS as u64);
486    let object = ((key_tag as u64) << 48)
487        | ((algorithm as u64) << 40)
488        | ((digest_type as u64) << 32)
489        | (digest_hash & 0xFFFF_FFFF);
490    let context = digest_hash;
491    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
492    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
493    NQuin {
494        subject,
495        predicate,
496        object,
497        context,
498        metadata,
499        parity,
500    }
501}
502
503/// Encode a generic DNS TXT or Front-Door entry into an `NQuin`.
504pub fn encode_txt_record(domain: &str, text: &str, ttl: u32, lane: PermissiveRoutingLane) -> NQuin {
505    let subject = q_hash(domain);
506    let pred_hash = q_hash("qualia:dns:txt");
507    let predicate = (pred_hash << 8) | (OP_DNS_TXT as u64);
508    let object = q_hash(text);
509    let context = DNS_CONTEXT_HASH;
510    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
511    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
512    NQuin {
513        subject,
514        predicate,
515        object,
516        context,
517        metadata,
518        parity,
519    }
520}
521
522/// Encode a Qualia Socially Defined Network (SDN) Front-Door entry into an `NQuin`.
523pub fn encode_sdn_front_door(
524    domain: &str,
525    did_topological_pointer: u64,
526    ttl: u32,
527    lane: PermissiveRoutingLane,
528) -> NQuin {
529    let subject = q_hash(domain);
530    let pred_hash = q_hash("qualia:sdn:frontDoor");
531    let predicate = (pred_hash << 8) | (OP_DNS_QDP_FRONT_DOOR as u64);
532    let object = did_topological_pointer;
533    let context = q_hash("qualia:sdn:overlay");
534    let metadata = ((lane as u64) << 61) | (ttl as u64 & 0xFFFF_FFFF);
535    let parity = NQuin::calculate_parity(subject, predicate, object, context, metadata);
536    NQuin {
537        subject,
538        predicate,
539        object,
540        context,
541        metadata,
542        parity,
543    }
544}
545
546/// Map a wire record view into an `NQuin`, resolving compressed domain names when present.
547pub fn wire_record_view_to_quin(
548    name: &str,
549    rec: &DnsRecordView<'_>,
550    lane: PermissiveRoutingLane,
551) -> Option<NQuin> {
552    match rec.rtype {
553        DnsType::A => {
554            if rec.rdata.len() != 4 {
555                return None;
556            }
557            let mut ip = [0u8; 4];
558            ip.copy_from_slice(rec.rdata);
559            Some(encode_a_record(name, ip, rec.ttl, lane))
560        }
561        DnsType::AAAA => {
562            if rec.rdata.len() != 16 {
563                return None;
564            }
565            let mut ip = [0u8; 16];
566            ip.copy_from_slice(rec.rdata);
567            Some(encode_aaaa_record(name, ip, rec.ttl, lane))
568        }
569        DnsType::CNAME => {
570            let mut buf = [0u8; 256];
571            let (_, len) =
572                super::wire::decode_domain_name(rec.packet, rec.rdata_offset, &mut buf).ok()?;
573            let target = std::str::from_utf8(&buf[..len]).ok()?;
574            Some(encode_cname_record(name, target, rec.ttl, lane))
575        }
576        DnsType::NS => {
577            let mut buf = [0u8; 256];
578            let (_, len) =
579                super::wire::decode_domain_name(rec.packet, rec.rdata_offset, &mut buf).ok()?;
580            let target = std::str::from_utf8(&buf[..len]).ok()?;
581            Some(encode_ns_record(name, target, rec.ttl, lane))
582        }
583        DnsType::PTR => {
584            let mut buf = [0u8; 256];
585            let (_, len) =
586                super::wire::decode_domain_name(rec.packet, rec.rdata_offset, &mut buf).ok()?;
587            let target = std::str::from_utf8(&buf[..len]).ok()?;
588            Some(encode_ptr_record(name, target, rec.ttl, lane))
589        }
590        DnsType::MX => {
591            if rec.rdata.len() < 2 {
592                return None;
593            }
594            let preference = u16::from_be_bytes([rec.rdata[0], rec.rdata[1]]);
595            let mut buf = [0u8; 256];
596            let (_, len) =
597                super::wire::decode_domain_name(rec.packet, rec.rdata_offset + 2, &mut buf).ok()?;
598            let exchange = std::str::from_utf8(&buf[..len]).ok()?;
599            Some(encode_mx_record(name, preference, exchange, rec.ttl, lane))
600        }
601        DnsType::SRV => {
602            if rec.rdata.len() < 6 {
603                return None;
604            }
605            let priority = u16::from_be_bytes([rec.rdata[0], rec.rdata[1]]);
606            let weight = u16::from_be_bytes([rec.rdata[2], rec.rdata[3]]);
607            let port = u16::from_be_bytes([rec.rdata[4], rec.rdata[5]]);
608            let mut buf = [0u8; 256];
609            let (_, len) =
610                super::wire::decode_domain_name(rec.packet, rec.rdata_offset + 6, &mut buf).ok()?;
611            let target = std::str::from_utf8(&buf[..len]).ok()?;
612            Some(encode_srv_record(
613                name, priority, weight, port, target, rec.ttl, lane,
614            ))
615        }
616        DnsType::CAA => {
617            if rec.rdata.len() < 2 {
618                return None;
619            }
620            let flags = rec.rdata[0];
621            let tag_len = rec.rdata[1] as usize;
622            if rec.rdata.len() < 2 + tag_len {
623                return None;
624            }
625            let tag = std::str::from_utf8(&rec.rdata[2..2 + tag_len]).ok()?;
626            let value = std::str::from_utf8(&rec.rdata[2 + tag_len..]).ok()?;
627            Some(encode_caa_record(name, flags, tag, value, rec.ttl, lane))
628        }
629        DnsType::TLSA => {
630            if rec.rdata.len() < 3 {
631                return None;
632            }
633            let usage = rec.rdata[0];
634            let selector = rec.rdata[1];
635            let mtype = rec.rdata[2];
636            let cert_hash = if rec.rdata.len() >= 11 {
637                let mut b = [0u8; 8];
638                b.copy_from_slice(&rec.rdata[3..11]);
639                u64::from_be_bytes(b)
640            } else {
641                0
642            };
643            Some(encode_tlsa_record(
644                name, usage, selector, mtype, cert_hash, rec.ttl, lane,
645            ))
646        }
647        DnsType::HTTPS | DnsType::SVCB => {
648            if rec.rdata.len() < 2 {
649                return None;
650            }
651            let priority = u16::from_be_bytes([rec.rdata[0], rec.rdata[1]]);
652            let mut buf = [0u8; 256];
653            let (next_off, len) =
654                super::wire::decode_domain_name(rec.packet, rec.rdata_offset + 2, &mut buf).ok()?;
655            let target = std::str::from_utf8(&buf[..len]).ok()?;
656            let params_hash =
657                if next_off < rec.packet.len() && next_off < rec.rdata_offset + rec.rdata.len() {
658                    let params = &rec.packet[next_off..rec.rdata_offset + rec.rdata.len()];
659                    let mut h = 0xcbf29ce484222325u64;
660                    for b in params {
661                        h = (h ^ (*b as u64)).wrapping_mul(0x100000001b3);
662                    }
663                    h
664                } else {
665                    0
666                };
667            Some(encode_https_record(
668                name,
669                priority,
670                target,
671                params_hash,
672                rec.ttl,
673                lane,
674            ))
675        }
676        DnsType::DNSKEY => {
677            if rec.rdata.len() < 4 {
678                return None;
679            }
680            let flags = u16::from_be_bytes([rec.rdata[0], rec.rdata[1]]);
681            let protocol = rec.rdata[2];
682            let algorithm = rec.rdata[3];
683            let mut h = 0xcbf29ce484222325u64;
684            for b in &rec.rdata[4..] {
685                h = (h ^ (*b as u64)).wrapping_mul(0x100000001b3);
686            }
687            Some(encode_dnskey_record(
688                name, flags, protocol, algorithm, h, rec.ttl, lane,
689            ))
690        }
691        DnsType::DS => {
692            if rec.rdata.len() < 4 {
693                return None;
694            }
695            let key_tag = u16::from_be_bytes([rec.rdata[0], rec.rdata[1]]);
696            let algorithm = rec.rdata[2];
697            let digest_type = rec.rdata[3];
698            let mut h = 0xcbf29ce484222325u64;
699            for b in &rec.rdata[4..] {
700                h = (h ^ (*b as u64)).wrapping_mul(0x100000001b3);
701            }
702            Some(encode_ds_record(
703                name,
704                key_tag,
705                algorithm,
706                digest_type,
707                h,
708                rec.ttl,
709                lane,
710            ))
711        }
712        DnsType::TXT => {
713            let mut text_buf = [0u8; 256];
714            let mut cursor = 0;
715            let mut out_len = 0;
716            while cursor < rec.rdata.len() {
717                let segment_len = rec.rdata[cursor] as usize;
718                cursor += 1;
719                if cursor + segment_len > rec.rdata.len() {
720                    break;
721                }
722                let copy_len = core::cmp::min(segment_len, text_buf.len() - out_len);
723                text_buf[out_len..out_len + copy_len]
724                    .copy_from_slice(&rec.rdata[cursor..cursor + copy_len]);
725                out_len += copy_len;
726                cursor += segment_len;
727            }
728            if let Ok(text) = std::str::from_utf8(&text_buf[..out_len]) {
729                Some(encode_txt_record(name, text, rec.ttl, lane))
730            } else {
731                None
732            }
733        }
734        _ => None,
735    }
736}
737
738/// Fallback wrapper for raw RDATA when full packet is not provided.
739pub fn wire_record_to_quin(
740    name: &str,
741    rtype: DnsType,
742    ttl: u32,
743    rdata: &[u8],
744    lane: PermissiveRoutingLane,
745) -> Option<NQuin> {
746    let dummy_packet = rdata;
747    let rec = DnsRecordView {
748        rtype,
749        rclass: 1,
750        ttl,
751        rdata,
752        rdata_offset: 0,
753        packet: dummy_packet,
754    };
755    wire_record_view_to_quin(name, &rec, lane)
756}
757
758#[cfg(test)]
759mod tests {
760    use super::*;
761
762    #[test]
763    fn a_record_roundtrip() {
764        let quin = encode_a_record(
765            "node1.qualia.net",
766            [192, 168, 1, 42],
767            300,
768            PermissiveRoutingLane::EnforceBilateralMicroCommons,
769        );
770        assert!(quin.verify_ecc_parity());
771        assert_eq!(
772            quin.identify_routing_lane(),
773            PermissiveRoutingLane::EnforceBilateralMicroCommons
774        );
775
776        let (ip, ttl, lane) = decode_a_record(&quin).unwrap();
777        assert_eq!(ip, [192, 168, 1, 42]);
778        assert_eq!(ttl, 300);
779        assert_eq!(lane, PermissiveRoutingLane::EnforceBilateralMicroCommons);
780    }
781
782    #[test]
783    fn aaaa_record_lossless_roundtrip() {
784        let ip_v6: [u8; 16] = [
785            0x26, 0x06, 0x47, 0x00, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
786            0x11, 0x11,
787        ];
788        let quin = encode_aaaa_record(
789            "cloudflare-dns.com",
790            ip_v6,
791            3600,
792            PermissiveRoutingLane::PassthroughStandard,
793        );
794        assert!(quin.verify_ecc_parity());
795
796        let (decoded_ip, ttl, lane) = decode_aaaa_record(&quin).unwrap();
797        assert_eq!(decoded_ip, ip_v6);
798        assert_eq!(ttl, 3600);
799        assert_eq!(lane, PermissiveRoutingLane::PassthroughStandard);
800    }
801
802    #[test]
803    fn mx_record_roundtrip() {
804        let quin = encode_mx_record(
805            "qualia.net",
806            10,
807            "mail.qualia.net",
808            600,
809            PermissiveRoutingLane::PassthroughStandard,
810        );
811        assert!(quin.verify_ecc_parity());
812        let (pref, exch_hash, ttl, _) = decode_mx_record(&quin).unwrap();
813        assert_eq!(pref, 10);
814        assert_eq!(exch_hash, q_hash("mail.qualia.net") & 0x0000_FFFF_FFFF_FFFF);
815        assert_eq!(ttl, 600);
816    }
817
818    #[test]
819    fn srv_record_roundtrip() {
820        let quin = encode_srv_record(
821            "_imaps._tcp.qualia.net",
822            5,
823            0,
824            993,
825            "mail.qualia.net",
826            1800,
827            PermissiveRoutingLane::EnforceBilateralMicroCommons,
828        );
829        assert!(quin.verify_ecc_parity());
830        let (prio, weight, port, target_hash, ttl, _) = decode_srv_record(&quin).unwrap();
831        assert_eq!(prio, 5);
832        assert_eq!(weight, 0);
833        assert_eq!(port, 993);
834        assert_eq!(target_hash, q_hash("mail.qualia.net"));
835        assert_eq!(ttl, 1800);
836    }
837
838    #[test]
839    fn sdn_front_door_encoding() {
840        let did_ptr = DID_Q42_FLAG | 0x1234_5678_9ABC;
841        let quin = encode_sdn_front_door(
842            "alice.webizen.net",
843            did_ptr,
844            600,
845            PermissiveRoutingLane::EnforcePermissiveCommons,
846        );
847        assert!(quin.verify_ecc_parity());
848        assert_eq!(quin.object & DID_Q42_FLAG, DID_Q42_FLAG);
849        assert_eq!(
850            quin.identify_routing_lane(),
851            PermissiveRoutingLane::EnforcePermissiveCommons
852        );
853    }
854}