foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-01-20 20:42:19 -05:00
Code Issues Packages 1 Wiki Activity

feat(ext/net): Dns resolving for tts

Browse source
This commit is contained in:
siaeyy 2025-01-15 05:25:19 +03:00
parent 406162d7b8
commit f5d1f3f038
1 changed files with 70 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

114
ext/net/ops.rs
View file

@ -561,7 +561,7 @@ where
#[derive(Serialize, Eq, PartialEq, Debug)]
#[serde(untagged)]
pub enum DnsReturnRecord {
pub enum DnsRecordData {
A(String),
Aaaa(String),
Aname(String),
@ -603,6 +603,20 @@ pub enum DnsReturnRecord {
Txt(Vec<String>),
}
#[derive(Serialize, Eq, PartialEq, Debug)]
#[serde()]
pub struct DnsRecordWithTtl {
pub data: DnsRecordData,
pub ttl: u32,
}
#[derive(Serialize, Eq, PartialEq, Debug)]
#[serde(untagged)]
pub enum DnsReturnRecord {
WithoutTtl(DnsRecordData),
WithTtl(DnsRecordWithTtl),
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResolveAddrArgs {
@ -616,6 +630,7 @@ pub struct ResolveAddrArgs {
#[serde(rename_all = "camelCase")]
pub struct ResolveDnsOption {
name_server: Option<NameServer>,
ttl: Option<bool>,
}
fn default_port() -> u16 {
@ -662,6 +677,8 @@ where
system_conf::read_system_conf()?
};
let ttl = options.as_ref().and_then(|o| o.ttl).unwrap_or(false);
{
let mut s = state.borrow_mut();
let perm = s.borrow_mut::<NP>();
@ -720,8 +737,20 @@ where
}
_ => NetError::Dns(e),
})?
.records()
.iter()
.filter_map(|rdata| rdata_to_return_record(record_type)(rdata).transpose())
.filter_map(|rec| {
let data = format_rdata(record_type)(rec.data()).unwrap();
if ttl {
Some(DnsReturnRecord::WithTtl(DnsRecordWithTtl {
data: data?,
ttl: rec.ttl(),
}))
} else {
Some(DnsReturnRecord::WithoutTtl(data?))
}
})
.map(Ok)
.collect::<Result<Vec<DnsReturnRecord>, NetError>>()
}
@ -765,22 +794,22 @@ pub fn op_set_keepalive_inner(
resource.set_keepalive(keepalive).map_err(NetError::Map)
}
fn rdata_to_return_record(
fn format_rdata(
ty: RecordType,
) -> impl Fn(&RData) -> Result<Option<DnsReturnRecord>, NetError> {
) -> impl Fn(&RData) -> Result<Option<DnsRecordData>, NetError> {
use RecordType::*;
move |r: &RData| -> Result<Option<DnsReturnRecord>, NetError> {
move |r: &RData| -> Result<Option<DnsRecordData>, NetError> {
let record = match ty {
A => r.as_a().map(ToString::to_string).map(DnsReturnRecord::A),
A => r.as_a().map(ToString::to_string).map(DnsRecordData::A),
AAAA => r
.as_aaaa()
.map(ToString::to_string)
.map(DnsReturnRecord::Aaaa),
.map(DnsRecordData::Aaaa),
ANAME => r
.as_aname()
.map(ToString::to_string)
.map(DnsReturnRecord::Aname),
CAA => r.as_caa().map(|caa| DnsReturnRecord::Caa {
.map(DnsRecordData::Aname),
CAA => r.as_caa().map(|caa| DnsRecordData::Caa {
critical: caa.issuer_critical(),
tag: caa.tag().to_string(),
value: match caa.value() {
@ -807,12 +836,12 @@ fn rdata_to_return_record(
CNAME => r
.as_cname()
.map(ToString::to_string)
.map(DnsReturnRecord::Cname),
MX => r.as_mx().map(|mx| DnsReturnRecord::Mx {
.map(DnsRecordData::Cname),
MX => r.as_mx().map(|mx| DnsRecordData::Mx {
preference: mx.preference(),
exchange: mx.exchange().to_string(),
}),
NAPTR => r.as_naptr().map(|naptr| DnsReturnRecord::Naptr {
NAPTR => r.as_naptr().map(|naptr| DnsRecordData::Naptr {
order: naptr.order(),
preference: naptr.preference(),
flags: String::from_utf8(naptr.flags().to_vec()).unwrap(),
@ -820,12 +849,9 @@ fn rdata_to_return_record(
regexp: String::from_utf8(naptr.regexp().to_vec()).unwrap(),
replacement: naptr.replacement().to_string(),
}),
NS => r.as_ns().map(ToString::to_string).map(DnsReturnRecord::Ns),
PTR => r
.as_ptr()
.map(ToString::to_string)
.map(DnsReturnRecord::Ptr),
SOA => r.as_soa().map(|soa| DnsReturnRecord::Soa {
NS => r.as_ns().map(ToString::to_string).map(DnsRecordData::Ns),
PTR => r.as_ptr().map(ToString::to_string).map(DnsRecordData::Ptr),
SOA => r.as_soa().map(|soa| DnsRecordData::Soa {
mname: soa.mname().to_string(),
rname: soa.rname().to_string(),
serial: soa.serial(),
@ -834,7 +860,7 @@ fn rdata_to_return_record(
expire: soa.expire(),
minimum: soa.minimum(),
}),
SRV => r.as_srv().map(|srv| DnsReturnRecord::Srv {
SRV => r.as_srv().map(|srv| DnsRecordData::Srv {
priority: srv.priority(),
weight: srv.weight(),
port: srv.port(),
@ -848,7 +874,7 @@ fn rdata_to_return_record(
bytes.iter().map(|&b| b as char).collect::<String>()
})
.collect();
DnsReturnRecord::Txt(texts)
DnsRecordData::Txt(texts)
}),
_ => return Err(NetError::UnsupportedRecordType),
};
@ -891,37 +917,37 @@ mod tests {
#[test]
fn rdata_to_return_record_a() {
let func = rdata_to_return_record(RecordType::A);
let func = format_rdata(RecordType::A);
let rdata = RData::A(A(Ipv4Addr::new(127, 0, 0, 1)));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::A("127.0.0.1".to_string()))
Some(DnsRecordData::A("127.0.0.1".to_string()))
);
}
#[test]
fn rdata_to_return_record_aaaa() {
let func = rdata_to_return_record(RecordType::AAAA);
let func = format_rdata(RecordType::AAAA);
let rdata = RData::AAAA(AAAA(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Aaaa("::1".to_string()))
Some(DnsRecordData::Aaaa("::1".to_string()))
);
}
#[test]
fn rdata_to_return_record_aname() {
let func = rdata_to_return_record(RecordType::ANAME);
let func = format_rdata(RecordType::ANAME);
let rdata = RData::ANAME(ANAME(Name::new()));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Aname("".to_string()))
Some(DnsRecordData::Aname("".to_string()))
);
}
#[test]
fn rdata_to_return_record_caa() {
let func = rdata_to_return_record(RecordType::CAA);
let func = format_rdata(RecordType::CAA);
let rdata = RData::CAA(CAA::new_issue(
false,
Some(Name::parse("example.com", None).unwrap()),
@ -929,7 +955,7 @@ mod tests {
));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Caa {
Some(DnsRecordData::Caa {
critical: false,
tag: "issue".to_string(),
value: "example.com; account=123456".to_string(),
@ -939,21 +965,21 @@ mod tests {
#[test]
fn rdata_to_return_record_cname() {
let func = rdata_to_return_record(RecordType::CNAME);
let func = format_rdata(RecordType::CNAME);
let rdata = RData::CNAME(CNAME(Name::new()));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Cname("".to_string()))
Some(DnsRecordData::Cname("".to_string()))
);
}
#[test]
fn rdata_to_return_record_mx() {
let func = rdata_to_return_record(RecordType::MX);
let func = format_rdata(RecordType::MX);
let rdata = RData::MX(MX::new(10, Name::new()));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Mx {
Some(DnsRecordData::Mx {
preference: 10,
exchange: "".to_string()
})
@ -962,7 +988,7 @@ mod tests {
#[test]
fn rdata_to_return_record_naptr() {
let func = rdata_to_return_record(RecordType::NAPTR);
let func = format_rdata(RecordType::NAPTR);
let rdata = RData::NAPTR(NAPTR::new(
1,
2,
@ -973,7 +999,7 @@ mod tests {
));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Naptr {
Some(DnsRecordData::Naptr {
order: 1,
preference: 2,
flags: "".to_string(),
@ -986,27 +1012,27 @@ mod tests {
#[test]
fn rdata_to_return_record_ns() {
let func = rdata_to_return_record(RecordType::NS);
let func = format_rdata(RecordType::NS);
let rdata = RData::NS(NS(Name::new()));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Ns("".to_string()))
Some(DnsRecordData::Ns("".to_string()))
);
}
#[test]
fn rdata_to_return_record_ptr() {
let func = rdata_to_return_record(RecordType::PTR);
let func = format_rdata(RecordType::PTR);
let rdata = RData::PTR(PTR(Name::new()));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Ptr("".to_string()))
Some(DnsRecordData::Ptr("".to_string()))
);
}
#[test]
fn rdata_to_return_record_soa() {
let func = rdata_to_return_record(RecordType::SOA);
let func = format_rdata(RecordType::SOA);
let rdata = RData::SOA(SOA::new(
Name::new(),
Name::new(),
@ -1018,7 +1044,7 @@ mod tests {
));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Soa {
Some(DnsRecordData::Soa {
mname: "".to_string(),
rname: "".to_string(),
serial: 0,
@ -1032,11 +1058,11 @@ mod tests {
#[test]
fn rdata_to_return_record_srv() {
let func = rdata_to_return_record(RecordType::SRV);
let func = format_rdata(RecordType::SRV);
let rdata = RData::SRV(SRV::new(1, 2, 3, Name::new()));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Srv {
Some(DnsRecordData::Srv {
priority: 1,
weight: 2,
port: 3,
@ -1047,7 +1073,7 @@ mod tests {
#[test]
fn rdata_to_return_record_txt() {
let func = rdata_to_return_record(RecordType::TXT);
let func = format_rdata(RecordType::TXT);
let rdata = RData::TXT(TXT::from_bytes(vec![
"foo".as_bytes(),
"bar".as_bytes(),
@ -1056,7 +1082,7 @@ mod tests {
]));
assert_eq!(
func(&rdata).unwrap(),
Some(DnsReturnRecord::Txt(vec![
Some(DnsRecordData::Txt(vec![
"foo".to_string(),
"bar".to_string(),
"£".to_string(),