From 331a0a120d33a45b9d659995b437f2222b2d1716 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Thu, 17 Mar 2022 11:25:55 +0800 Subject: [PATCH] services: dns: add `RawLookup` opcode This lookup will be used by libstd in order to perform DNS queries. Signed-off-by: Sean Cross --- services/dns/src/api.rs | 50 +++++++++++-- services/dns/src/main.rs | 155 +++++++++++++++++++++++++++++++++------ 2 files changed, 175 insertions(+), 30 deletions(-) diff --git a/services/dns/src/api.rs b/services/dns/src/api.rs index 5d6b98416..11535cdfa 100644 --- a/services/dns/src/api.rs +++ b/services/dns/src/api.rs @@ -10,22 +10,56 @@ pub(crate) const DNS_PKT_MAX_LEN: usize = 512; /// These opcodes can be called by anyone at any time #[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)] +#[repr(C)] pub(crate) enum Opcode { - Lookup, - Flush, + Lookup = 0, + Flush = 1, /// used internally to update the TTL field, and eventually expire the cache (unless cache is frozen) - UpdateTtl, + UpdateTtl = 2, /// issuing this opcode causes all future attempts to change the DNS server configs to be ignored. This also freezes the cache. - FreezeConfig, - /// this allows automatic updates to the DNS server configs based on DHCP. This is the default state. - ThawConfig, + FreezeConfig = 3, - Quit, + /// this allows automatic updates to the DNS server configs based on DHCP. This is the default state. + ThawConfig = 4, + + Quit = 5, + + /// Perform a DNS lookup and return the results in a raw format. + /// + /// The query should be a `MutableBorrow` and should be a `&str` with the + /// `valid` parameter set to the length of the query. + /// + /// The result will be a `&[u8]` with the first field being `0` and the second + /// field indicating the number of results. + /// + /// # Errors + /// + /// If there is an error, then the first field is `1` and the second field is + /// an error code corresponding to `DnsResponseCode` + /// + /// # Success + /// + /// Upon successful return, a series of entries will begin at offset 2. Each + /// entry is a tag, followed by a number of octets. The tag indicates + /// how many octets follow: + /// + /// * 4: Ipv4 Address -- 4 octets follow, for a total of 5 bytes + /// * 6: Ipv6 Address -- 16 octets follow, for a total of 17 bytes + RawLookup = 6, } -#[derive(Debug, num_derive::FromPrimitive, num_derive::ToPrimitive, Archive, Serialize, Deserialize, Copy, Clone)] +#[derive( + Debug, + num_derive::FromPrimitive, + num_derive::ToPrimitive, + Archive, + Serialize, + Deserialize, + Copy, + Clone, +)] #[repr(u16)] pub enum DnsResponseCode { NoError = 0, diff --git a/services/dns/src/main.rs b/services/dns/src/main.rs index 73e492922..dfd2bc5f8 100644 --- a/services/dns/src/main.rs +++ b/services/dns/src/main.rs @@ -365,43 +365,120 @@ impl Resolver { let qclass = QueryClass::IN; let query = Message::query(qname, qtype, qclass, self.trng.get_u32().unwrap() as u16); - self.socket.send_to(&query.datagram, &server) - .map_err(|_| DnsResponseCode::NetworkError)?; + self.socket + .send_to(&query.datagram, &server) + .map_err(|_| DnsResponseCode::NetworkError)?; match self.socket.recv(&mut self.buf) { Ok(len) => { let message = Message::from(&self.buf[..len]); if message.id() == query.id() && message.is_response() { return match message.rcode() { - DnsResponseCode::NoError => { - message.parse_response() - } - rcode => { - Err(rcode) - } - } + DnsResponseCode::NoError => message.parse_response(), + rcode => Err(rcode), + }; } else { Err(DnsResponseCode::NetworkError) } } - Err(e) => { - match e.kind() { - ErrorKind::WouldBlock => { - Err(DnsResponseCode::NetworkError) - } - _ => { - Err(DnsResponseCode::UnknownError) - } - } - } + Err(e) => match e.kind() { + ErrorKind::WouldBlock => Err(DnsResponseCode::NetworkError), + _ => Err(DnsResponseCode::UnknownError), + }, } - } else { Err(DnsResponseCode::NoServerSpecified) } } } +#[derive(PartialEq, Debug)] +#[repr(C)] +enum NameConversionError { + /// The length of the memory buffer was invalid + InvalidMemoryBuffer = 1, + + /// The specified nameserver string was not UTF-8 + InvalidString = 3, + + /// The message was not a mutable memory message + InvalidMessageType = 4, +} + +fn name_from_msg(env: &xous::MessageEnvelope) -> Result<&str, NameConversionError> { + let msg = env + .body + .memory_message() + .ok_or(NameConversionError::InvalidMessageType)?; + let valid_bytes = msg.valid.map(|v| v.get()).unwrap_or_else(|| msg.buf.len()); + if valid_bytes > DNS_NAME_LENGTH_LIMIT || valid_bytes < 1 { + log::error!("valid bytes exceeded DNS name limit"); + return Err(NameConversionError::InvalidMemoryBuffer); + } + // Safe because we've already validated that it's a valid range + let str_slice = unsafe { core::slice::from_raw_parts(msg.buf.as_ptr(), valid_bytes) }; + let name_string = + core::str::from_utf8(str_slice).map_err(|_| NameConversionError::InvalidString)?; + + Ok(name_string) +} + +fn fill_response(mut env: xous::MessageEnvelope, entries: &HashMap) -> Option<()> { + let mem = env.body.memory_message_mut()?; + + let s: &mut [u8] = mem.buf.as_slice_mut(); + let mut i = s.iter_mut(); + + // First tag = 1 for "Error" -- we'll fill this in at the end when it's successful + *i.next()? = 1; + + // Limit the number of entries to 128, which is a nice number. Given that an IPv6 + // address is 17 bytes, that means that ~240 IPv6 addresses will fit in a 4 kB page. + // 128 is just a conservative value rounded down. + let mut entry_count = entries.len(); + if entry_count > 128 { + entry_count = 128; + } + *i.next()? = entry_count.try_into().ok()?; + + // Start filling in the addreses + for addr in entries.keys() { + match addr { + &IpAddr::V4(a) => { + // IPv4 + *i.next()? = 4; + for entry in a.octets() { + *i.next()? = entry; + } + } + &IpAddr::V6(a) => { + // IPv6 + for entry in a.octets() { + *i.next()? = entry; + } + *i.next()? = 6; + } + } + } + + // Convert the entry to a "Success" message + drop(i); + s[0] = 0; + + None +} + +fn fill_error(mut env: xous::MessageEnvelope, code: DnsResponseCode) -> Option<()> { + let mem = env.body.memory_message_mut()?; + + let s: &mut [u8] = mem.buf.as_slice_mut(); + let mut i = s.iter_mut(); + + *i.next()? = 1; + *i.next()? = code as u8; + None +} + #[xous::xous_main] fn xmain() -> ! { log_server::init_wait().unwrap(); @@ -448,9 +525,43 @@ fn xmain() -> ! { loop { let mut msg = xous::receive_message(dns_sid).unwrap(); match FromPrimitive::from_usize(msg.body.id()) { + Some(Opcode::RawLookup) => { + match name_from_msg(&msg).map(|s| s.to_owned()) { + Ok(owned_name) => { + log::trace!("performing a lookup of {}", owned_name); + // Try to get the result out of the DNS cache + if let Some(entries) = dns_cache.get(&owned_name) { + fill_response(msg, entries); + continue; + } + + // This entry is not in the cache, so perform a lookup + match resolver.resolve(&owned_name) { + Ok(cache_entry) => { + fill_response(msg, &cache_entry); + dns_cache.insert(owned_name, cache_entry); + continue; + } + Err(e) => { + fill_error(msg, e); + continue; + } + } + } + Err(e) => { + log::error!("unable to do name lookup: {:?}", e); + fill_error(msg, DnsResponseCode::NameError); + continue; + } + }; + } Some(Opcode::Lookup) => { - let mut buf = unsafe{Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap())}; - let name = buf.to_original::, _>().unwrap(); + let mut buf = unsafe { + Buffer::from_memory_message_mut(msg.body.memory_message_mut().unwrap()) + }; + let name = buf + .to_original::, _>() + .unwrap(); let name_std = std::string::String::from(name.as_str().unwrap()); if let Some(cache_entry) = dns_cache.get(&name_std) { // pick a random entry