foster/deno
0
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-03-07 03:42:40 -05:00
Code Issues Packages1 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

114
ext/net/ops.rs
View file

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