1#![allow(dead_code)]
10
11use super::wire::{DnsRecordView, DnsType};
12use crate::{q_hash, NQuin, PermissiveRoutingLane};
13
14pub 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
34pub const INLINE_TAG_INTEGER: u64 = 0b001u64 << 60;
36pub const DID_Q42_FLAG: u64 = 1u64 << 63;
38
39pub const DNS_CONTEXT_HASH: u64 = q_hash("qualia:dns:zone");
41
42pub 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
67pub 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
83pub 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
115pub 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
128pub 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
152pub 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
164pub 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
183pub 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
195pub 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
219pub 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
231pub 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
257pub 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
272pub 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
298pub 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
315pub 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
342pub 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
361pub 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
387pub 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
417pub 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
443pub 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
473pub 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
503pub 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
522pub 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
546pub 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
738pub 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}