feat: WIP MDNS crate #6

+21

.tangled/workflows/miri.yml

··· 1 1 + when: 2 2 + - event: ["push", "pull_request"] 3 3 + branch: main 4 4 + 5 5 + engine: nixery 6 6 + 7 7 + dependencies: 8 8 + nixpkgs: 9 9 + - clang 10 10 + - rustup 11 11 + 12 12 + steps: 13 13 + - name: Install Nightly 14 14 + command: | 15 15 + rustup toolchain install nightly --component miri 16 16 + rustup override set nightly 17 17 + cargo miri setup 18 18 + - name: Miri Test 19 19 + command: cargo miri test --locked -p sachy-mdns 20 20 + environment: 21 21 + RUSTFLAGS: -Zrandomize-layout

+19 -3

Cargo.lock

··· 420 420 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" 421 421 dependencies = [ 422 422 "libc", 423 423 - "windows-sys 0.52.0", 423 423 + "windows-sys 0.61.2", 424 424 ] 425 425 426 426 [[package]] ··· 1065 1065 "errno", 1066 1066 "libc", 1067 1067 "linux-raw-sys 0.11.0", 1068 1068 - "windows-sys 0.52.0", 1068 1068 + "windows-sys 0.61.2", 1069 1069 ] 1070 1070 1071 1071 [[package]] ··· 1119 1119 name = "sachy-fnv" 1120 1120 version = "0.1.0" 1121 1121 1122 1122 + [[package]] 1123 1123 + name = "sachy-mdns" 1124 1124 + version = "0.1.0" 1125 1125 + dependencies = [ 1126 1126 + "defmt 1.0.1", 1127 1127 + "embassy-time", 1128 1128 + "sachy-fmt", 1129 1129 + "winnow", 1130 1130 + ] 1131 1131 + 1122 1132 [[package]] 1123 1133 name = "sachy-shtc3" 1124 1134 version = "0.1.0" ··· 1292 1302 "getrandom", 1293 1303 "once_cell", 1294 1304 "rustix 1.1.2", 1295 1295 - "windows-sys 0.52.0", 1305 1305 + "windows-sys 0.61.2", 1296 1306 ] 1297 1307 1298 1308 [[package]] ··· 1483 1493 source = "registry+https://github.com/rust-lang/crates.io-index" 1484 1494 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" 1485 1495 1496 1496 + [[package]] 1497 1497 + name = "winnow" 1498 1498 + version = "0.7.14" 1499 1499 + source = "registry+https://github.com/rust-lang/crates.io-index" 1500 1500 + checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" 1501 1501 + 1486 1502 [[package]] 1487 1503 name = "wit-bindgen" 1488 1504 version = "0.46.0"

+1

Cargo.toml

··· 6 6 "sachy-esphome", 7 7 "sachy-fmt", 8 8 "sachy-fnv", 9 9 + "sachy-mdns", 9 10 "sachy-shtc3", 10 11 "sachy-sntp", 11 12 ]

+22

sachy-mdns/Cargo.toml

··· 1 1 + [package] 2 2 + name = "sachy-mdns" 3 3 + authors.workspace = true 4 4 + edition.workspace = true 5 5 + repository.workspace = true 6 6 + license.workspace = true 7 7 + version.workspace = true 8 8 + rust-version.workspace = true 9 9 + 10 10 + [dependencies] 11 11 + defmt = { workspace = true, optional = true, features = ["alloc"] } 12 12 + embassy-time = { workspace = true } 13 13 + sachy-fmt = { path = "../sachy-fmt" } 14 14 + winnow = { version = "0.7.12", default-features = false } 15 15 + 16 16 + [features] 17 17 + default = [] 18 18 + std = [] 19 19 + defmt = ["dep:defmt"] 20 20 + 21 21 + [dev-dependencies] 22 22 + winnow = { version = "0.7.12", default-features = false, features = ["alloc"] }

+6

sachy-mdns/src/dns.rs

··· 1 1 + pub(crate) mod flags; 2 2 + pub(crate) mod label; 3 3 + pub(crate) mod query; 4 4 + pub(crate) mod records; 5 5 + pub(crate) mod reqres; 6 6 + pub mod traits;

+231

sachy-mdns/src/dns/flags.rs

··· 1 1 + #![allow(dead_code)] 2 2 + 3 3 + use core::{convert::Infallible, fmt}; 4 4 + use winnow::{ModalResult, Parser, binary::be_u16}; 5 5 + 6 6 + use crate::{ 7 7 + dns::traits::{DnsParse, DnsSerialize}, 8 8 + encoder::Encoder, 9 9 + }; 10 10 + 11 11 + #[derive(Default, Clone, Copy, PartialEq, Eq)] 12 12 + pub struct Flags(pub u16); 13 13 + 14 14 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 15 15 + #[repr(u8)] 16 16 + pub enum Opcode { 17 17 + Query = 0, 18 18 + IQuery = 1, 19 19 + Status = 2, 20 20 + Reserved = 3, 21 21 + Notify = 4, 22 22 + Update = 5, 23 23 + // Other values are reserved 24 24 + } 25 25 + 26 26 + impl Opcode { 27 27 + const fn cast(value: u8) -> Self { 28 28 + match value { 29 29 + 0 => Opcode::Query, 30 30 + 1 => Opcode::IQuery, 31 31 + 2 => Opcode::Status, 32 32 + 4 => Opcode::Notify, 33 33 + 5 => Opcode::Update, 34 34 + _ => Opcode::Reserved, 35 35 + } 36 36 + } 37 37 + } 38 38 + 39 39 + impl From<u8> for Opcode { 40 40 + fn from(value: u8) -> Self { 41 41 + Self::cast(value) 42 42 + } 43 43 + } 44 44 + 45 45 + impl From<Opcode> for u8 { 46 46 + fn from(opcode: Opcode) -> Self { 47 47 + opcode as u8 48 48 + } 49 49 + } 50 50 + 51 51 + impl Flags { 52 52 + const fn new() -> Self { 53 53 + Flags(0) 54 54 + } 55 55 + 56 56 + pub const fn standard_request() -> Self { 57 57 + let mut flags = Flags::new(); 58 58 + flags.set_query(true); 59 59 + flags.set_opcode(Opcode::Query); 60 60 + flags.set_recursion_desired(true); 61 61 + flags 62 62 + } 63 63 + 64 64 + pub const fn standard_response() -> Self { 65 65 + let mut flags = Flags::new(); 66 66 + flags.set_query(false); 67 67 + flags.set_opcode(Opcode::Query); 68 68 + flags.set_authoritative(true); 69 69 + flags.set_recursion_available(false); 70 70 + flags 71 71 + } 72 72 + 73 73 + // QR: Query/Response Flag 74 74 + pub const fn is_query(&self) -> bool { 75 75 + (self.0 & 0x8000) == 0 76 76 + } 77 77 + 78 78 + pub const fn set_query(&mut self, is_query: bool) { 79 79 + if is_query { 80 80 + self.0 &= !0x8000; 81 81 + } else { 82 82 + self.0 |= 0x8000; 83 83 + } 84 84 + } 85 85 + 86 86 + // Opcode (bits 1-4) 87 87 + pub const fn get_opcode(&self) -> Opcode { 88 88 + Opcode::cast(((self.0 >> 11) & 0x0F) as u8) 89 89 + } 90 90 + 91 91 + pub const fn set_opcode(&mut self, opcode: Opcode) { 92 92 + self.0 = (self.0 & !0x7800) | (((opcode as u8) as u16 & 0x0F) << 11); 93 93 + } 94 94 + 95 95 + // AA: Authoritative Answer 96 96 + pub const fn is_authoritative(&self) -> bool { 97 97 + (self.0 & 0x0400) != 0 98 98 + } 99 99 + 100 100 + pub const fn set_authoritative(&mut self, authoritative: bool) { 101 101 + if authoritative { 102 102 + self.0 |= 0x0400; 103 103 + } else { 104 104 + self.0 &= !0x0400; 105 105 + } 106 106 + } 107 107 + 108 108 + // TC: Truncated 109 109 + pub const fn is_truncated(&self) -> bool { 110 110 + (self.0 & 0x0200) != 0 111 111 + } 112 112 + 113 113 + pub const fn set_truncated(&mut self, truncated: bool) { 114 114 + if truncated { 115 115 + self.0 |= 0x0200; 116 116 + } else { 117 117 + self.0 &= !0x0200; 118 118 + } 119 119 + } 120 120 + 121 121 + // RD: Recursion Desired 122 122 + pub const fn is_recursion_desired(&self) -> bool { 123 123 + (self.0 & 0x0100) != 0 124 124 + } 125 125 + 126 126 + pub const fn set_recursion_desired(&mut self, recursion_desired: bool) { 127 127 + if recursion_desired { 128 128 + self.0 |= 0x0100; 129 129 + } else { 130 130 + self.0 &= !0x0100; 131 131 + } 132 132 + } 133 133 + 134 134 + // RA: Recursion Available 135 135 + pub const fn is_recursion_available(&self) -> bool { 136 136 + (self.0 & 0x0080) != 0 137 137 + } 138 138 + 139 139 + pub const fn set_recursion_available(&mut self, recursion_available: bool) { 140 140 + if recursion_available { 141 141 + self.0 |= 0x0080; 142 142 + } else { 143 143 + self.0 &= !0x0080; 144 144 + } 145 145 + } 146 146 + 147 147 + // Z: Reserved for future use (bits 9-11) 148 148 + pub const fn get_reserved(&self) -> u8 { 149 149 + ((self.0 >> 4) & 0x07) as u8 150 150 + } 151 151 + 152 152 + pub const fn set_reserved(&mut self, reserved: u8) { 153 153 + self.0 = (self.0 & !0x0070) | ((reserved as u16 & 0x07) << 4); 154 154 + } 155 155 + 156 156 + // RCODE: Response Code (bits 12-15) 157 157 + pub const fn get_rcode(&self) -> u8 { 158 158 + (self.0 & 0x000F) as u8 159 159 + } 160 160 + 161 161 + pub const fn set_rcode(&mut self, rcode: u8) { 162 162 + self.0 = (self.0 & !0x000F) | (rcode as u16 & 0x0F); 163 163 + } 164 164 + } 165 165 + 166 166 + impl<'a> DnsParse<'a> for Flags { 167 167 + fn parse(input: &mut &'a [u8], _context: &'a [u8]) -> ModalResult<Self> { 168 168 + be_u16.map(Flags).parse_next(input) 169 169 + } 170 170 + } 171 171 + 172 172 + impl<'a> DnsSerialize<'a> for Flags { 173 173 + type Error = Infallible; 174 174 + 175 175 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 176 176 + encoder.write(&self.0.to_be_bytes()); 177 177 + Ok(()) 178 178 + } 179 179 + 180 180 + fn size(&self) -> usize { 181 181 + core::mem::size_of::<u16>() 182 182 + } 183 183 + } 184 184 + 185 185 + impl fmt::Debug for Flags { 186 186 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 187 187 + f.debug_struct("Flags") 188 188 + .field("query", &self.is_query()) 189 189 + .field("opcode", &self.get_opcode()) 190 190 + .field("authoritative", &self.is_authoritative()) 191 191 + .field("truncated", &self.is_truncated()) 192 192 + .field("recursion_desired", &self.is_recursion_desired()) 193 193 + .field("recursion_available", &self.is_recursion_available()) 194 194 + .field("reserved", &self.get_reserved()) 195 195 + .field("rcode", &self.get_rcode()) 196 196 + .finish() 197 197 + } 198 198 + } 199 199 + 200 200 + #[cfg(feature = "defmt")] 201 201 + impl defmt::Format for Flags { 202 202 + fn format(&self, fmt: defmt::Formatter) { 203 203 + defmt::write!( 204 204 + fmt, 205 205 + "Flags {{ query: {}, opcode: {:?}, authoritative: {}, truncated: {}, recursion_desired: {}, recursion_available: {}, reserved: {}, rcode: {} }}", 206 206 + self.is_query(), 207 207 + self.get_opcode(), 208 208 + self.is_authoritative(), 209 209 + self.is_truncated(), 210 210 + self.is_recursion_desired(), 211 211 + self.is_recursion_available(), 212 212 + self.get_reserved(), 213 213 + self.get_rcode() 214 214 + ); 215 215 + } 216 216 + } 217 217 + 218 218 + #[cfg(feature = "defmt")] 219 219 + impl defmt::Format for Opcode { 220 220 + fn format(&self, fmt: defmt::Formatter) { 221 221 + let opcode_str = match self { 222 222 + Opcode::Query => "Query", 223 223 + Opcode::IQuery => "IQuery", 224 224 + Opcode::Status => "Status", 225 225 + Opcode::Reserved => "Reserved", 226 226 + Opcode::Notify => "Notify", 227 227 + Opcode::Update => "Update", 228 228 + }; 229 229 + defmt::write!(fmt, "Opcode({=str})", opcode_str); 230 230 + } 231 231 + }

+511

sachy-mdns/src/dns/label.rs

··· 1 1 + use core::{fmt, str}; 2 2 + 3 3 + use winnow::{ 4 4 + ModalResult, Parser, 5 5 + binary::be_u8, 6 6 + error::{ContextError, ErrMode, FromExternalError}, 7 7 + stream::Offset, 8 8 + token::take, 9 9 + }; 10 10 + 11 11 + use crate::{ 12 12 + dns::traits::{DnsParse, DnsSerialize}, 13 13 + encoder::{DnsError, Encoder, MAX_STR_LEN, PTR_MASK}, 14 14 + }; 15 15 + 16 16 + #[derive(Clone, Copy)] 17 17 + pub struct Label<'a> { 18 18 + repr: LabelRepr<'a>, 19 19 + } 20 20 + 21 21 + impl<'a> From<&'a str> for Label<'a> { 22 22 + fn from(value: &'a str) -> Self { 23 23 + Self { 24 24 + repr: LabelRepr::Str(value), 25 25 + } 26 26 + } 27 27 + } 28 28 + 29 29 + impl<'a> DnsSerialize<'a> for Label<'a> { 30 30 + type Error = DnsError; 31 31 + 32 32 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 33 33 + match self.repr { 34 34 + LabelRepr::Bytes { 35 35 + context, 36 36 + start, 37 37 + end, 38 38 + } => { 39 39 + encoder.write(&context[start..end]); 40 40 + 41 41 + Ok(()) 42 42 + } 43 43 + LabelRepr::Str(label) => encoder.write_label(label), 44 44 + } 45 45 + } 46 46 + 47 47 + fn size(&self) -> usize { 48 48 + match self.repr { 49 49 + LabelRepr::Bytes { 50 50 + context, 51 51 + start, 52 52 + end, 53 53 + } => core::mem::size_of_val(&context[start..end]), 54 54 + LabelRepr::Str(label) => core::mem::size_of_val(label) + 1, 55 55 + } 56 56 + } 57 57 + } 58 58 + 59 59 + impl<'a> DnsParse<'a> for Label<'a> { 60 60 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self> { 61 61 + let start = input.offset_from(&context); 62 62 + let mut end = start; 63 63 + 64 64 + loop { 65 65 + match LabelSegment::parse(input)? { 66 66 + LabelSegment::Empty => { 67 67 + end += 1; 68 68 + break; 69 69 + } 70 70 + LabelSegment::String(label) => { 71 71 + end += 1 + label.len(); 72 72 + } 73 73 + LabelSegment::Pointer(_) => { 74 74 + end += 2; 75 75 + break; 76 76 + } 77 77 + } 78 78 + } 79 79 + 80 80 + Ok(Self { 81 81 + repr: LabelRepr::Bytes { 82 82 + context, 83 83 + start, 84 84 + end, 85 85 + }, 86 86 + }) 87 87 + } 88 88 + } 89 89 + 90 90 + impl Label<'_> { 91 91 + pub fn segments(&self) -> impl Iterator<Item = LabelSegment<'_>> { 92 92 + self.repr.iter() 93 93 + } 94 94 + 95 95 + pub fn names(&self) -> impl Iterator<Item = &'_ str> { 96 96 + match self.repr { 97 97 + LabelRepr::Str(view) => Either::A(view.split('.')), 98 98 + LabelRepr::Bytes { context, start, .. } => Either::B( 99 99 + LabelSegmentBytesIter::new(context, start).flat_map(|label| label.as_str()), 100 100 + ), 101 101 + } 102 102 + } 103 103 + 104 104 + pub fn is_empty(&self) -> bool { 105 105 + self.repr.iter().next().is_none() 106 106 + } 107 107 + } 108 108 + 109 109 + #[derive(Clone, Copy, PartialEq, Eq)] 110 110 + enum LabelRepr<'a> { 111 111 + Bytes { 112 112 + context: &'a [u8], 113 113 + start: usize, 114 114 + end: usize, 115 115 + }, 116 116 + Str(&'a str), 117 117 + } 118 118 + 119 119 + /// A DNS-compatible label segment. 120 120 + #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] 121 121 + pub enum LabelSegment<'a> { 122 122 + /// The empty terminator. 123 123 + Empty, 124 124 + 125 125 + /// A string label. 126 126 + String(&'a str), 127 127 + 128 128 + /// A pointer to a previous name. 129 129 + Pointer(u16), 130 130 + } 131 131 + 132 132 + impl<'a> LabelSegment<'a> { 133 133 + fn parse(input: &mut &'a [u8]) -> ModalResult<Self> { 134 134 + let b1 = be_u8(input)?; 135 135 + 136 136 + match b1 { 137 137 + 0 => Ok(Self::Empty), 138 138 + b1 if b1 & PTR_MASK == PTR_MASK => { 139 139 + let b2 = be_u8(input)?; 140 140 + 141 141 + let ptr = u16::from_be_bytes([b1 & !PTR_MASK, b2]); 142 142 + 143 143 + Ok(Self::Pointer(ptr)) 144 144 + } 145 145 + len => { 146 146 + if len > MAX_STR_LEN { 147 147 + return Err(ErrMode::Cut(ContextError::from_external_error( 148 148 + input, DnsError::LabelTooLong, 149 149 + ))); 150 150 + } 151 151 + 152 152 + let segment = take(len).try_map(core::str::from_utf8).parse_next(input)?; 153 153 + 154 154 + Ok(Self::String(segment)) 155 155 + } 156 156 + } 157 157 + } 158 158 + 159 159 + /// ## Safety 160 160 + /// The caller upholds that this function is not called when parsing from newly received data. Data that 161 161 + /// has yet to be determined to be a valid [`Label`] should be parsed and validated with [`Label::parse`], 162 162 + /// and that the entire data/context has been validated, not just a portion of it. 163 163 + #[inline] 164 164 + unsafe fn parse_unchecked(input: &'a [u8]) -> Option<Self> { 165 165 + input.split_first().map(|(b1, input)| match *b1 { 166 166 + 0 => Self::Empty, 167 167 + b1 if b1 & PTR_MASK == PTR_MASK => { 168 168 + // SAFETY: The caller has already validated that a second byte is available for a 169 169 + // Pointer segment. 170 170 + let b2 = unsafe { *input.get_unchecked(0) }; 171 171 + 172 172 + let ptr = u16::from_be_bytes([b1 & !PTR_MASK, b2]); 173 173 + 174 174 + Self::Pointer(ptr) 175 175 + } 176 176 + len => { 177 177 + // SAFETY: The caller has validated that this length value is correct and will only 178 178 + // access within the bounds of the provided slice. 179 179 + let segment = unsafe { input.get_unchecked(0..(len as usize)) }; 180 180 + // SAFETY: The caller has upheld the validity of the bytes as valid UTF-8 once before. 181 181 + let segment = unsafe { core::str::from_utf8_unchecked(segment) }; 182 182 + 183 183 + Self::String(segment) 184 184 + } 185 185 + }) 186 186 + } 187 187 + 188 188 + fn as_str(&self) -> Option<&'a str> { 189 189 + match self { 190 190 + Self::String(label) => Some(*label), 191 191 + _ => None, 192 192 + } 193 193 + } 194 194 + } 195 195 + 196 196 + pub struct LabelSegmentBytesIter<'a> { 197 197 + context: &'a [u8], 198 198 + start: usize, 199 199 + } 200 200 + 201 201 + impl<'a> LabelSegmentBytesIter<'a> { 202 202 + pub(crate) fn new(context: &'a [u8], start: usize) -> Self { 203 203 + Self { context, start } 204 204 + } 205 205 + } 206 206 + 207 207 + impl<'a> Iterator for LabelSegmentBytesIter<'a> { 208 208 + type Item = LabelSegment<'a>; 209 209 + 210 210 + fn next(&mut self) -> Option<Self::Item> { 211 211 + loop { 212 212 + let view = &self.context[self.start..]; 213 213 + 214 214 + // SAFETY: The segment has already been validated, so they should be all valid variants and UTF-8 bytes 215 215 + let segment = unsafe { LabelSegment::parse_unchecked(view)? }; 216 216 + 217 217 + match segment { 218 218 + LabelSegment::String(label) => { 219 219 + self.start = self.start.saturating_add(label.len() + 1); 220 220 + return Some(segment); 221 221 + } 222 222 + LabelSegment::Pointer(ptr) => { 223 223 + self.start = ptr as usize; 224 224 + } 225 225 + LabelSegment::Empty => { 226 226 + // Set the index offset to be len() so that the view is empty and terminates the loop 227 227 + self.start = self.context.len(); 228 228 + return Some(LabelSegment::Empty); 229 229 + } 230 230 + } 231 231 + } 232 232 + } 233 233 + } 234 234 + 235 235 + impl<'a> LabelRepr<'a> { 236 236 + fn iter(&self) -> impl Iterator<Item = LabelSegment<'a>> { 237 237 + match *self { 238 238 + LabelRepr::Bytes { context, start, .. } => { 239 239 + Either::A(LabelSegmentBytesIter::new(context, start)) 240 240 + } 241 241 + LabelRepr::Str(view) => Either::B( 242 242 + view.split('.') 243 243 + .map(LabelSegment::String) 244 244 + .chain(Some(LabelSegment::Empty)), 245 245 + ), 246 246 + } 247 247 + } 248 248 + } 249 249 + 250 250 + impl fmt::Debug for Label<'_> { 251 251 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 252 252 + struct LabelFmt<'a>(&'a Label<'a>); 253 253 + 254 254 + impl fmt::Debug for LabelFmt<'_> { 255 255 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 256 256 + fmt::Display::fmt(self.0, f) 257 257 + } 258 258 + } 259 259 + 260 260 + f.debug_tuple("Label").field(&LabelFmt(self)).finish() 261 261 + } 262 262 + } 263 263 + 264 264 + impl fmt::Display for Label<'_> { 265 265 + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 266 266 + let mut names = self.names(); 267 267 + 268 268 + if let Some(name) = names.next() { 269 269 + f.write_str(name)?; 270 270 + 271 271 + names.try_for_each(|name| { 272 272 + f.write_str(".")?; 273 273 + f.write_str(name) 274 274 + }) 275 275 + } else { 276 276 + Ok(()) 277 277 + } 278 278 + } 279 279 + } 280 280 + 281 281 + impl<'a, 'b> PartialEq<Label<'a>> for Label<'b> { 282 282 + fn eq(&self, other: &Label<'a>) -> bool { 283 283 + self.segments().eq(other.segments()) 284 284 + } 285 285 + } 286 286 + 287 287 + impl Eq for Label<'_> {} 288 288 + 289 289 + impl PartialEq<&str> for Label<'_> { 290 290 + fn eq(&self, other: &&str) -> bool { 291 291 + let mut self_iter = self.names(); 292 292 + let mut other_iter = other.split('.'); 293 293 + 294 294 + loop { 295 295 + match (self_iter.next(), other_iter.next()) { 296 296 + (Some(self_part), Some(other_part)) => { 297 297 + if self_part != other_part { 298 298 + return false; 299 299 + } 300 300 + } 301 301 + (None, None) => return true, 302 302 + _ => return false, 303 303 + } 304 304 + } 305 305 + } 306 306 + } 307 307 + 308 308 + #[cfg(feature = "defmt")] 309 309 + impl defmt::Format for Label<'_> { 310 310 + fn format(&self, fmt: defmt::Formatter) { 311 311 + defmt::write!(fmt, "Label("); 312 312 + let mut iter = self.names(); 313 313 + if let Some(first) = iter.next() { 314 314 + defmt::write!(fmt, "{}", first); 315 315 + 316 316 + iter.for_each(|part| defmt::write!(fmt, ".{}", part)); 317 317 + } 318 318 + defmt::write!(fmt, ")"); 319 319 + } 320 320 + } 321 321 + 322 322 + /// One iterator or another. 323 323 + enum Either<A, B> { 324 324 + A(A), 325 325 + B(B), 326 326 + } 327 327 + 328 328 + impl<A: Iterator, Other: Iterator<Item = A::Item>> Iterator for Either<A, Other> { 329 329 + type Item = A::Item; 330 330 + 331 331 + fn next(&mut self) -> Option<Self::Item> { 332 332 + match self { 333 333 + Either::A(a) => a.next(), 334 334 + Either::B(b) => b.next(), 335 335 + } 336 336 + } 337 337 + 338 338 + fn size_hint(&self) -> (usize, Option<usize>) { 339 339 + match self { 340 340 + Either::A(a) => a.size_hint(), 341 341 + Either::B(b) => b.size_hint(), 342 342 + } 343 343 + } 344 344 + 345 345 + fn fold<B, F>(self, init: B, f: F) -> B 346 346 + where 347 347 + Self: Sized, 348 348 + F: FnMut(B, Self::Item) -> B, 349 349 + { 350 350 + match self { 351 351 + Either::A(a) => a.fold(init, f), 352 352 + Either::B(b) => b.fold(init, f), 353 353 + } 354 354 + } 355 355 + } 356 356 + 357 357 + #[cfg(test)] 358 358 + mod test { 359 359 + use super::*; 360 360 + 361 361 + #[test] 362 362 + fn segments_iter_test() { 363 363 + let label: Label<'static> = Label::from("_service._udp.local"); 364 364 + let mut segments = label.segments(); 365 365 + 366 366 + assert_eq!(segments.next(), Some(LabelSegment::String("_service"))); 367 367 + assert_eq!(segments.next(), Some(LabelSegment::String("_udp"))); 368 368 + assert_eq!(segments.next(), Some(LabelSegment::String("local"))); 369 369 + assert_eq!(segments.next(), Some(LabelSegment::Empty)); 370 370 + assert_eq!(segments.next(), None); 371 371 + 372 372 + // example.com with a pointer to the start 373 373 + let data = b"\x07example\x03com\x00\xC0\x00"; 374 374 + let context = &data[..]; 375 375 + // The data here is entirely valid, even though we parse only a portion of it. 376 376 + let label = Label::parse(&mut &data[13..], context).unwrap(); 377 377 + 378 378 + let mut segments = label.segments(); 379 379 + assert_eq!(segments.next(), Some(LabelSegment::String("example"))); 380 380 + assert_eq!(segments.next(), Some(LabelSegment::String("com"))); 381 381 + assert_eq!(segments.next(), Some(LabelSegment::Empty)); 382 382 + assert_eq!(segments.next(), None); 383 383 + } 384 384 + 385 385 + #[test] 386 386 + fn names_iter_test() { 387 387 + let label: Label<'static> = Label::from("_service._udp.local"); 388 388 + let mut names = label.names(); 389 389 + 390 390 + assert_eq!(names.next(), Some("_service")); 391 391 + assert_eq!(names.next(), Some("_udp")); 392 392 + assert_eq!(names.next(), Some("local")); 393 393 + assert_eq!(names.next(), None); 394 394 + 395 395 + let data = b"\x07example\x03com\x00\xC0\x00"; 396 396 + let context = &data[..]; 397 397 + // The data here is entirely valid, even though we parse only a portion of it. 398 398 + let label = Label::parse(&mut &data[13..], context).unwrap(); 399 399 + 400 400 + let mut names = label.names(); 401 401 + assert_eq!(names.next(), Some("example")); 402 402 + assert_eq!(names.next(), Some("com")); 403 403 + assert_eq!(names.next(), None); 404 404 + } 405 405 + 406 406 + #[test] 407 407 + fn serialize_str_label() { 408 408 + let label: Label<'static> = Label::from("_service._udp.local"); 409 409 + let mut buffer = [0u8; 256]; 410 410 + let mut buffer = Encoder::new(&mut buffer); 411 411 + label.serialize(&mut buffer).unwrap(); 412 412 + assert_eq!(buffer.finish(), b"\x08_service\x04_udp\x05local\x00"); 413 413 + } 414 414 + 415 415 + #[test] 416 416 + fn serialize_compressed_str_label() { 417 417 + let label: Label<'static> = Label::from("_service._udp.local"); 418 418 + let label2: Label<'static> = Label::from("other._udp.local"); 419 419 + let mut buffer = [0u8; 256]; 420 420 + let mut buffer = Encoder::new(&mut buffer); 421 421 + label.serialize(&mut buffer).unwrap(); 422 422 + label2.serialize(&mut buffer).unwrap(); 423 423 + assert_eq!( 424 424 + buffer.finish(), 425 425 + b"\x08_service\x04_udp\x05local\x00\x05other\xC0\x09" 426 426 + ); 427 427 + } 428 428 + 429 429 + #[test] 430 430 + fn round_trip_compressed_str_label() { 431 431 + let label: Label<'static> = Label::from("_service._udp.local"); 432 432 + let label2: Label<'static> = Label::from("other._udp.local"); 433 433 + let mut buffer = [0u8; 256]; 434 434 + let mut buffer = Encoder::new(&mut buffer); 435 435 + label.serialize(&mut buffer).unwrap(); 436 436 + label2.serialize(&mut buffer).unwrap(); 437 437 + let context = buffer.finish(); 438 438 + assert_eq!( 439 439 + context, 440 440 + b"\x08_service\x04_udp\x05local\x00\x05other\xC0\x09" 441 441 + ); 442 442 + let view = &mut &context[..]; 443 443 + 444 444 + let parsed_label = Label::parse(view, context).unwrap(); 445 445 + let parsed_label2 = Label::parse(view, context).unwrap(); 446 446 + 447 447 + let parsed_label_count = parsed_label.segments().count(); 448 448 + let parsed_label2_count = parsed_label2.segments().count(); 449 449 + 450 450 + // Both have same amount of segments. 451 451 + assert_eq!(parsed_label_count, parsed_label2_count); 452 452 + 453 453 + assert_eq!(parsed_label, label); 454 454 + assert_eq!(parsed_label2, label2); 455 455 + } 456 456 + 457 457 + #[test] 458 458 + fn label_byte_repr_serialization_quick_path() { 459 459 + let data = b"\x07example\x03com\x00\xC0\x00"; 460 460 + let context = &data[..]; 461 461 + // The data here is entirely valid, even though we parse only a portion of it. 462 462 + let label = Label::parse(&mut &data[13..], context).unwrap(); 463 463 + 464 464 + let mut buffer = [0u8; 256]; 465 465 + let mut buffer = Encoder::new(&mut buffer); 466 466 + label.serialize(&mut buffer).unwrap(); 467 467 + // If the original Label is just a pointer, the new output will be a pointer, assuming 468 468 + // the original data is also present in the output 469 469 + assert_eq!(buffer.finish(), b"\xC0\x00"); 470 470 + } 471 471 + 472 472 + #[test] 473 473 + fn parse_and_eq_created_label() { 474 474 + let data = b"\x07example\x03com\x00\xC0\x00"; 475 475 + let context = &data[..]; 476 476 + 477 477 + // The data here is entirely valid, even though we parse only a portion of it. 478 478 + let parsed_label = Label::parse(&mut &data[13..], context).unwrap(); 479 479 + 480 480 + let created_label = Label::from("example.com"); 481 481 + 482 482 + assert_eq!(parsed_label, created_label); 483 483 + } 484 484 + 485 485 + #[test] 486 486 + fn parse_and_eq_label_with_str() { 487 487 + let data = b"\x07example\x03com\x00"; 488 488 + let context = &data[..]; 489 489 + 490 490 + let parsed_label = Label::parse(&mut &data[..], context).unwrap(); 491 491 + 492 492 + assert_eq!(parsed_label, "example.com"); 493 493 + } 494 494 + 495 495 + #[test] 496 496 + fn parse_ptr_label_and_eq_with_str() { 497 497 + let data = b"\x07example\x03com\x00\xC0\x00"; 498 498 + let context = &data[..]; 499 499 + 500 500 + // The data here is entirely valid, even though we parse only a portion of it. 501 501 + let parsed_label = Label::parse(&mut &data[13..], context).unwrap(); 502 502 + 503 503 + assert_eq!(parsed_label, "example.com"); 504 504 + } 505 505 + 506 506 + #[test] 507 507 + fn label_new_without_dot_is_not_empty() { 508 508 + let label: Label = Label::from("example"); 509 509 + assert!(!label.is_empty()); 510 510 + } 511 511 + }

+228

sachy-mdns/src/dns/query.rs

··· 1 1 + use winnow::binary::{be_u16, be_u32}; 2 2 + use winnow::{ModalResult, Parser}; 3 3 + 4 4 + use super::label::Label; 5 5 + use super::records::Record; 6 6 + use crate::encoder::Encoder; 7 7 + use crate::{ 8 8 + dns::{ 9 9 + records::QType, 10 10 + traits::{DnsParse, DnsParseKind, DnsSerialize}, 11 11 + }, 12 12 + encoder::DnsError, 13 13 + }; 14 14 + 15 15 + #[derive(Debug, PartialEq, Eq)] 16 16 + pub struct Query<'a> { 17 17 + pub name: Label<'a>, 18 18 + pub qtype: QType, 19 19 + pub qclass: QClass, 20 20 + } 21 21 + 22 22 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 23 23 + #[repr(u16)] 24 24 + pub enum QClass { 25 25 + IN = 1, 26 26 + Multicast = 32769, // (IN + Cache flush bit) 27 27 + Unknown(u16), 28 28 + } 29 29 + 30 30 + impl<'a> DnsParse<'a> for Query<'a> { 31 31 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self> { 32 32 + let name = Label::parse(input, context)?; 33 33 + let qtype = QType::parse(input, context)?; 34 34 + let qclass = be_u16.map(QClass::from_u16).parse_next(input)?; 35 35 + 36 36 + Ok(Query { 37 37 + name, 38 38 + qtype, 39 39 + qclass, 40 40 + }) 41 41 + } 42 42 + } 43 43 + 44 44 + impl<'a> DnsSerialize<'a> for Query<'a> { 45 45 + type Error = DnsError; 46 46 + 47 47 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 48 48 + self.name.serialize(encoder)?; 49 49 + self.qtype.serialize(encoder).ok(); 50 50 + encoder.write(&self.qclass.to_u16().to_be_bytes()); 51 51 + Ok(()) 52 52 + } 53 53 + 54 54 + fn size(&self) -> usize { 55 55 + self.name.size() + self.qtype.size() + core::mem::size_of::<QClass>() 56 56 + } 57 57 + } 58 58 + 59 59 + #[derive(Debug, PartialEq, Eq)] 60 60 + pub struct Answer<'a> { 61 61 + pub name: Label<'a>, 62 62 + pub atype: QType, 63 63 + pub aclass: QClass, 64 64 + pub ttl: u32, 65 65 + pub record: Record<'a>, 66 66 + } 67 67 + 68 68 + impl QClass { 69 69 + fn from_u16(value: u16) -> Self { 70 70 + match value { 71 71 + 1 => QClass::IN, 72 72 + 32769 => QClass::Multicast, 73 73 + _ => QClass::Unknown(value), 74 74 + } 75 75 + } 76 76 + 77 77 + fn to_u16(self) -> u16 { 78 78 + match self { 79 79 + QClass::IN => 1, 80 80 + QClass::Multicast => 32769, 81 81 + QClass::Unknown(value) => value, 82 82 + } 83 83 + } 84 84 + } 85 85 + 86 86 + impl<'a> DnsParse<'a> for Answer<'a> { 87 87 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self> { 88 88 + let name = Label::parse(input, context)?; 89 89 + let atype = QType::parse(input, context)?; 90 90 + let aclass = be_u16.map(QClass::from_u16).parse_next(input)?; 91 91 + 92 92 + let ttl = be_u32.parse_next(input)?; 93 93 + let record = atype.parse_kind(input, context)?; 94 94 + 95 95 + Ok(Answer { 96 96 + name, 97 97 + atype, 98 98 + aclass, 99 99 + ttl, 100 100 + record, 101 101 + }) 102 102 + } 103 103 + } 104 104 + 105 105 + impl<'a> DnsSerialize<'a> for Answer<'a> { 106 106 + type Error = DnsError; 107 107 + 108 108 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 109 109 + self.name.serialize(encoder)?; 110 110 + self.atype.serialize(encoder).ok(); 111 111 + encoder.write(&self.aclass.to_u16().to_be_bytes()); 112 112 + encoder.write(&self.ttl.to_be_bytes()); 113 113 + self.record.serialize(encoder) 114 114 + } 115 115 + 116 116 + fn size(&self) -> usize { 117 117 + self.name.size() 118 118 + + self.atype.size() 119 119 + + core::mem::size_of::<QClass>() 120 120 + + core::mem::size_of::<u32>() 121 121 + + self.record.size() 122 122 + } 123 123 + } 124 124 + 125 125 + #[cfg(feature = "defmt")] 126 126 + impl<'a> defmt::Format for Query<'a> { 127 127 + fn format(&self, fmt: defmt::Formatter) { 128 128 + defmt::write!( 129 129 + fmt, 130 130 + "Query {{ name: {:?}, qtype: {:?}, qclass: {:?} }}", 131 131 + self.name, 132 132 + self.qtype, 133 133 + self.qclass 134 134 + ); 135 135 + } 136 136 + } 137 137 + 138 138 + #[cfg(feature = "defmt")] 139 139 + impl defmt::Format for QType { 140 140 + fn format(&self, fmt: defmt::Formatter) { 141 141 + let qtype_str = match self { 142 142 + QType::A => "A", 143 143 + QType::AAAA => "AAAA", 144 144 + QType::PTR => "PTR", 145 145 + QType::TXT => "TXT", 146 146 + QType::SRV => "SRV", 147 147 + QType::Any => "Any", 148 148 + QType::Unknown(_) => "Unknown", 149 149 + }; 150 150 + defmt::write!(fmt, "QType({=str})", qtype_str); 151 151 + } 152 152 + } 153 153 + 154 154 + #[cfg(feature = "defmt")] 155 155 + impl defmt::Format for QClass { 156 156 + fn format(&self, fmt: defmt::Formatter) { 157 157 + let qclass_str = match self { 158 158 + QClass::IN => "IN", 159 159 + QClass::Multicast => "Multicast", 160 160 + QClass::Unknown(_) => "Unknown", 161 161 + }; 162 162 + defmt::write!(fmt, "QClass({=str})", qclass_str); 163 163 + } 164 164 + } 165 165 + 166 166 + #[cfg(feature = "defmt")] 167 167 + impl<'a> defmt::Format for Answer<'a> { 168 168 + fn format(&self, fmt: defmt::Formatter) { 169 169 + defmt::write!( 170 170 + fmt, 171 171 + "Answer {{ name: {:?}, atype: {:?}, aclass: {:?}, ttl: {}, record: {:?} }}", 172 172 + self.name, 173 173 + self.atype, 174 174 + self.aclass, 175 175 + self.ttl, 176 176 + self.record 177 177 + ); 178 178 + } 179 179 + } 180 180 + 181 181 + #[cfg(test)] 182 182 + mod tests { 183 183 + use super::*; 184 184 + use crate::dns::records::A; 185 185 + use core::net::Ipv4Addr; 186 186 + 187 187 + #[test] 188 188 + fn roundtrip_query() { 189 189 + let name = Label::from("example.local"); 190 190 + 191 191 + let query = Query { 192 192 + name, 193 193 + qtype: QType::A, 194 194 + qclass: QClass::IN, 195 195 + }; 196 196 + 197 197 + let mut buffer = [0u8; 256]; 198 198 + let mut buffer = Encoder::new(&mut buffer); 199 199 + query.serialize(&mut buffer).unwrap(); 200 200 + let buffer = buffer.finish(); 201 201 + let parsed_query = Query::parse(&mut &buffer[..], buffer).unwrap(); 202 202 + 203 203 + assert_eq!(query, parsed_query); 204 204 + } 205 205 + 206 206 + #[test] 207 207 + fn roundtrip_answer() { 208 208 + let name = Label::from("example.local"); 209 209 + 210 210 + let answer: Answer = Answer { 211 211 + name, 212 212 + atype: QType::A, 213 213 + aclass: QClass::IN, 214 214 + ttl: 120, 215 215 + record: Record::A(A { 216 216 + address: Ipv4Addr::new(192, 168, 1, 1), 217 217 + }), 218 218 + }; 219 219 + 220 220 + let mut buffer = [0u8; 256]; 221 221 + let mut buffer = Encoder::new(&mut buffer); 222 222 + answer.serialize(&mut buffer).unwrap(); 223 223 + let buffer = buffer.finish(); 224 224 + let parsed_answer = Answer::parse(&mut &buffer[..], buffer).unwrap(); 225 225 + 226 226 + assert_eq!(answer, parsed_answer); 227 227 + } 228 228 + }

+413

sachy-mdns/src/dns/records.rs

··· 1 1 + use core::{ 2 2 + convert::Infallible, 3 3 + net::{Ipv4Addr, Ipv6Addr}, 4 4 + str, 5 5 + }; 6 6 + 7 7 + use alloc::vec::Vec; 8 8 + use winnow::token::take; 9 9 + use winnow::{ModalResult, Parser}; 10 10 + use winnow::{binary::be_u8, error::ContextError}; 11 11 + use winnow::{binary::be_u16, error::FromExternalError}; 12 12 + 13 13 + use super::label::Label; 14 14 + use crate::{ 15 15 + dns::traits::{DnsParse, DnsParseKind, DnsSerialize}, 16 16 + encoder::{DnsError, Encoder}, 17 17 + }; 18 18 + 19 19 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 20 20 + #[repr(u16)] 21 21 + #[allow(clippy::upper_case_acronyms)] 22 22 + pub enum QType { 23 23 + A = 1, 24 24 + AAAA = 28, 25 25 + PTR = 12, 26 26 + TXT = 16, 27 27 + SRV = 33, 28 28 + Any = 255, 29 29 + Unknown(u16), 30 30 + } 31 31 + 32 32 + impl<'a> DnsParse<'a> for QType { 33 33 + fn parse(input: &mut &'a [u8], _context: &'a [u8]) -> ModalResult<Self> { 34 34 + be_u16.map(QType::from_u16).parse_next(input) 35 35 + } 36 36 + } 37 37 + 38 38 + impl<'a> DnsSerialize<'a> for QType { 39 39 + type Error = Infallible; 40 40 + 41 41 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 42 42 + encoder.write(&self.to_u16().to_be_bytes()); 43 43 + Ok(()) 44 44 + } 45 45 + 46 46 + fn size(&self) -> usize { 47 47 + core::mem::size_of::<QType>() 48 48 + } 49 49 + } 50 50 + 51 51 + impl<'a> DnsParseKind<'a> for QType { 52 52 + type Output = Record<'a>; 53 53 + 54 54 + fn parse_kind(&self, input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self::Output> { 55 55 + match self { 56 56 + QType::A => { 57 57 + let record = A::parse(input, context)?; 58 58 + Ok(Record::A(record)) 59 59 + } 60 60 + QType::AAAA => { 61 61 + let record = AAAA::parse(input, context)?; 62 62 + Ok(Record::AAAA(record)) 63 63 + } 64 64 + QType::PTR => { 65 65 + let record = PTR::parse(input, context)?; 66 66 + Ok(Record::PTR(record)) 67 67 + } 68 68 + QType::TXT => { 69 69 + let record = TXT::parse(input, context)?; 70 70 + Ok(Record::TXT(record)) 71 71 + } 72 72 + QType::SRV => { 73 73 + let record = SRV::parse(input, context)?; 74 74 + Ok(Record::SRV(record)) 75 75 + } 76 76 + QType::Any => Err(winnow::error::ErrMode::Backtrack( 77 77 + ContextError::from_external_error(input, DnsError::Unsupported), 78 78 + )), 79 79 + QType::Unknown(_) => Err(winnow::error::ErrMode::Backtrack( 80 80 + ContextError::from_external_error(input, DnsError::Unsupported), 81 81 + )), 82 82 + } 83 83 + } 84 84 + } 85 85 + 86 86 + impl QType { 87 87 + fn from_u16(value: u16) -> Self { 88 88 + match value { 89 89 + 1 => QType::A, 90 90 + 28 => QType::AAAA, 91 91 + 12 => QType::PTR, 92 92 + 16 => QType::TXT, 93 93 + 33 => QType::SRV, 94 94 + 255 => QType::Any, 95 95 + _ => QType::Unknown(value), 96 96 + } 97 97 + } 98 98 + 99 99 + fn to_u16(self) -> u16 { 100 100 + match self { 101 101 + QType::A => 1, 102 102 + QType::AAAA => 28, 103 103 + QType::PTR => 12, 104 104 + QType::TXT => 16, 105 105 + QType::SRV => 33, 106 106 + QType::Any => 255, 107 107 + QType::Unknown(value) => value, 108 108 + } 109 109 + } 110 110 + } 111 111 + 112 112 + #[derive(Debug, PartialEq, Eq)] 113 113 + #[allow(clippy::upper_case_acronyms)] 114 114 + // Enum for DNS-SD records 115 115 + pub enum Record<'a> { 116 116 + A(A), 117 117 + AAAA(AAAA), 118 118 + PTR(PTR<'a>), 119 119 + TXT(TXT<'a>), 120 120 + SRV(SRV<'a>), 121 121 + } 122 122 + 123 123 + impl<'a> DnsSerialize<'a> for Record<'a> { 124 124 + type Error = DnsError; 125 125 + 126 126 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 127 127 + match self { 128 128 + Record::A(record) => { 129 129 + record.serialize(encoder).ok(); 130 130 + } 131 131 + Record::AAAA(record) => { 132 132 + record.serialize(encoder).ok(); 133 133 + } 134 134 + Record::PTR(record) => { 135 135 + record.serialize(encoder)?; 136 136 + } 137 137 + Record::TXT(record) => { 138 138 + record.serialize(encoder).ok(); 139 139 + } 140 140 + Record::SRV(record) => { 141 141 + record.serialize(encoder)?; 142 142 + } 143 143 + }; 144 144 + 145 145 + Ok(()) 146 146 + } 147 147 + 148 148 + fn size(&self) -> usize { 149 149 + match self { 150 150 + Self::A(a) => a.size(), 151 151 + Self::AAAA(aaaa) => aaaa.size(), 152 152 + Self::PTR(ptr) => ptr.size(), 153 153 + Self::TXT(txt) => txt.size(), 154 154 + Self::SRV(srv) => srv.size(), 155 155 + } 156 156 + } 157 157 + } 158 158 + 159 159 + // Struct for A record 160 160 + #[derive(Debug, PartialEq, Eq)] 161 161 + pub struct A { 162 162 + pub address: Ipv4Addr, 163 163 + } 164 164 + 165 165 + impl<'a> DnsParse<'a> for A { 166 166 + fn parse(input: &mut &'a [u8], _context: &'a [u8]) -> ModalResult<Self> { 167 167 + let len = be_u16.parse_next(input)?; 168 168 + let address = take(len) 169 169 + .try_map(<[u8; 4]>::try_from) 170 170 + .map(Ipv4Addr::from) 171 171 + .parse_next(input)?; 172 172 + 173 173 + Ok(A { address }) 174 174 + } 175 175 + } 176 176 + 177 177 + impl<'a> DnsSerialize<'a> for A { 178 178 + type Error = Infallible; 179 179 + 180 180 + fn serialize(&self, writer: &mut Encoder<'_, '_>) -> Result<(), Self::Error> { 181 181 + let len = 4u16.to_be_bytes(); 182 182 + writer.write(&len); 183 183 + writer.write(&self.address.octets()); 184 184 + Ok(()) 185 185 + } 186 186 + 187 187 + fn size(&self) -> usize { 188 188 + core::mem::size_of::<Ipv4Addr>() + core::mem::size_of::<u16>() 189 189 + } 190 190 + } 191 191 + 192 192 + // Struct for AAAA record 193 193 + #[derive(Debug, PartialEq, Eq)] 194 194 + #[allow(clippy::upper_case_acronyms)] 195 195 + pub struct AAAA { 196 196 + pub address: Ipv6Addr, 197 197 + } 198 198 + 199 199 + impl<'a> DnsParse<'a> for AAAA { 200 200 + fn parse(input: &mut &'a [u8], _context: &'a [u8]) -> ModalResult<Self> { 201 201 + let len = be_u16.parse_next(input)?; 202 202 + let address = take(len) 203 203 + .try_map(<[u8; 16]>::try_from) 204 204 + .map(Ipv6Addr::from) 205 205 + .parse_next(input)?; 206 206 + 207 207 + Ok(AAAA { address }) 208 208 + } 209 209 + } 210 210 + 211 211 + impl<'a> DnsSerialize<'a> for AAAA { 212 212 + type Error = Infallible; 213 213 + 214 214 + fn serialize(&self, writer: &mut Encoder<'_, '_>) -> Result<(), Self::Error> { 215 215 + let len = 16u16.to_be_bytes(); 216 216 + writer.write(&len); 217 217 + writer.write(&self.address.octets()); 218 218 + Ok(()) 219 219 + } 220 220 + 221 221 + fn size(&self) -> usize { 222 222 + core::mem::size_of::<Ipv6Addr>() + core::mem::size_of::<u16>() 223 223 + } 224 224 + } 225 225 + 226 226 + // Struct for PTR record 227 227 + #[derive(Debug, PartialEq, Eq)] 228 228 + #[allow(clippy::upper_case_acronyms)] 229 229 + pub struct PTR<'a> { 230 230 + pub name: Label<'a>, 231 231 + } 232 232 + 233 233 + impl<'a> DnsParse<'a> for PTR<'a> { 234 234 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self> { 235 235 + let _ = be_u16.parse_next(input)?; 236 236 + let name = Label::parse(input, context)?; 237 237 + Ok(PTR { name }) 238 238 + } 239 239 + } 240 240 + 241 241 + impl<'a> DnsSerialize<'a> for PTR<'a> { 242 242 + type Error = DnsError; 243 243 + 244 244 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 245 245 + encoder.with_record_length(|enc| self.name.serialize(enc)) 246 246 + } 247 247 + 248 248 + fn size(&self) -> usize { 249 249 + self.name.size() + core::mem::size_of::<u16>() 250 250 + } 251 251 + } 252 252 + 253 253 + // Struct for TXT record 254 254 + #[derive(Debug, PartialEq, Eq)] 255 255 + #[allow(clippy::upper_case_acronyms)] 256 256 + pub struct TXT<'a> { 257 257 + pub text: Vec<&'a str>, 258 258 + } 259 259 + 260 260 + impl<'a> DnsParse<'a> for TXT<'a> { 261 261 + fn parse(input: &mut &'a [u8], _context: &'a [u8]) -> ModalResult<Self> { 262 262 + let text_len = be_u16.parse_next(input)?; 263 263 + 264 264 + let mut total = 0u16; 265 265 + let mut text = Vec::new(); 266 266 + 267 267 + while total < text_len { 268 268 + let len = be_u8(input)?; 269 269 + 270 270 + total += 1 + len as u16; 271 271 + 272 272 + if len > 0 { 273 273 + let part = take(len).try_map(core::str::from_utf8).parse_next(input)?; 274 274 + text.push(part); 275 275 + } 276 276 + } 277 277 + 278 278 + Ok(TXT { text }) 279 279 + } 280 280 + } 281 281 + 282 282 + impl<'a> DnsSerialize<'a> for TXT<'a> { 283 283 + type Error = DnsError; 284 284 + 285 285 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 286 286 + encoder.with_record_length(|enc| { 287 287 + self.text.iter().try_for_each(|&part| { 288 288 + let text_len = u8::try_from(part.len()) 289 289 + .map_err(|_| DnsError::InvalidTxt) 290 290 + .map(u8::to_be_bytes)?; 291 291 + 292 292 + enc.write(&text_len); 293 293 + enc.write(part.as_bytes()); 294 294 + 295 295 + Ok(()) 296 296 + }) 297 297 + }) 298 298 + } 299 299 + 300 300 + fn size(&self) -> usize { 301 301 + let len_size = core::mem::size_of::<u16>(); 302 302 + 303 303 + let text_size = if self.text.is_empty() { 304 304 + 1 305 305 + } else { 306 306 + self.text.iter().map(|part| part.len() + 1).sum() 307 307 + }; 308 308 + 309 309 + len_size + text_size 310 310 + } 311 311 + } 312 312 + 313 313 + // Struct for SRV record 314 314 + #[derive(Debug, PartialEq, Eq)] 315 315 + #[allow(clippy::upper_case_acronyms)] 316 316 + pub struct SRV<'a> { 317 317 + pub priority: u16, 318 318 + pub weight: u16, 319 319 + pub port: u16, 320 320 + pub target: Label<'a>, 321 321 + } 322 322 + 323 323 + impl<'a> DnsParse<'a> for SRV<'a> { 324 324 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self> { 325 325 + let _ = be_u16.parse_next(input)?; 326 326 + let priority = be_u16.parse_next(input)?; 327 327 + let weight = be_u16.parse_next(input)?; 328 328 + let port = be_u16.parse_next(input)?; 329 329 + let target = Label::parse(input, context)?; 330 330 + 331 331 + Ok(SRV { 332 332 + priority, 333 333 + weight, 334 334 + port, 335 335 + target, 336 336 + }) 337 337 + } 338 338 + } 339 339 + 340 340 + impl<'a> DnsSerialize<'a> for SRV<'a> { 341 341 + type Error = DnsError; 342 342 + 343 343 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 344 344 + encoder.with_record_length(|enc| { 345 345 + enc.write(&self.priority.to_be_bytes()); 346 346 + enc.write(&self.weight.to_be_bytes()); 347 347 + enc.write(&self.port.to_be_bytes()); 348 348 + 349 349 + self.target.serialize(enc) 350 350 + }) 351 351 + } 352 352 + 353 353 + fn size(&self) -> usize { 354 354 + (core::mem::size_of::<u16>() * 4) + self.target.size() 355 355 + } 356 356 + } 357 357 + 358 358 + #[cfg(feature = "defmt")] 359 359 + impl defmt::Format for A { 360 360 + fn format(&self, fmt: defmt::Formatter) { 361 361 + // use crate::format::FormatIpv4Addr; 362 362 + defmt::write!(fmt, "A({})", self.address) 363 363 + } 364 364 + } 365 365 + 366 366 + #[cfg(feature = "defmt")] 367 367 + impl defmt::Format for AAAA { 368 368 + fn format(&self, fmt: defmt::Formatter) { 369 369 + // use crate::format::FormatIpv6Addr; 370 370 + defmt::write!(fmt, "AAAA({})", self.address) 371 371 + } 372 372 + } 373 373 + 374 374 + #[cfg(feature = "defmt")] 375 375 + impl<'a> defmt::Format for Record<'a> { 376 376 + fn format(&self, fmt: defmt::Formatter) { 377 377 + match self { 378 378 + Record::A(record) => defmt::write!(fmt, "Record::A({:?})", record), 379 379 + Record::AAAA(record) => defmt::write!(fmt, "Record::AAAA({:?})", record), 380 380 + Record::PTR(record) => defmt::write!(fmt, "Record::PTR({:?})", record), 381 381 + Record::TXT(record) => defmt::write!(fmt, "Record::TXT({:?})", record), 382 382 + Record::SRV(record) => defmt::write!(fmt, "Record::SRV({:?})", record), 383 383 + } 384 384 + } 385 385 + } 386 386 + 387 387 + #[cfg(feature = "defmt")] 388 388 + impl<'a> defmt::Format for PTR<'a> { 389 389 + fn format(&self, fmt: defmt::Formatter) { 390 390 + defmt::write!(fmt, "PTR {{ name: {:?} }}", self.name); 391 391 + } 392 392 + } 393 393 + 394 394 + #[cfg(feature = "defmt")] 395 395 + impl<'a> defmt::Format for TXT<'a> { 396 396 + fn format(&self, fmt: defmt::Formatter) { 397 397 + defmt::write!(fmt, "TXT {{ text: {:?} }}", self.text); 398 398 + } 399 399 + } 400 400 + 401 401 + #[cfg(feature = "defmt")] 402 402 + impl<'a> defmt::Format for SRV<'a> { 403 403 + fn format(&self, fmt: defmt::Formatter) { 404 404 + defmt::write!( 405 405 + fmt, 406 406 + "SRV {{ priority: {}, weight: {}, port: {}, target: {:?} }}", 407 407 + self.priority, 408 408 + self.weight, 409 409 + self.port, 410 410 + self.target 411 411 + ); 412 412 + } 413 413 + }

+481

sachy-mdns/src/dns/reqres.rs

··· 1 1 + use alloc::vec::Vec; 2 2 + use winnow::ModalResult; 3 3 + use winnow::binary::be_u16; 4 4 + 5 5 + use super::flags::Flags; 6 6 + use super::query::{Answer, Query}; 7 7 + use crate::{ 8 8 + dns::traits::{DnsParse, DnsSerialize}, 9 9 + encoder::{DnsError, Encoder}, 10 10 + }; 11 11 + 12 12 + const ZERO_U16: [u8; 2] = 0u16.to_be_bytes(); 13 13 + 14 14 + #[derive(Debug, PartialEq, Eq)] 15 15 + pub struct Request<'a> { 16 16 + pub id: u16, 17 17 + pub flags: Flags, 18 18 + pub(crate) queries: Vec<Query<'a>>, 19 19 + } 20 20 + 21 21 + impl<'a> DnsParse<'a> for Request<'a> { 22 22 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self> { 23 23 + let id = be_u16(input)?; 24 24 + let flags = Flags::parse(input, context)?; 25 25 + let qdcount = be_u16(input)?; 26 26 + let _ancount = be_u16(input)?; 27 27 + let _nscount = be_u16(input)?; 28 28 + let _arcount = be_u16(input)?; 29 29 + let queries = (0..qdcount) 30 30 + .map(|_| Query::parse(input, context)) 31 31 + .collect::<Result<Vec<_>, _>>()?; 32 32 + Ok(Request { id, flags, queries }) 33 33 + } 34 34 + } 35 35 + 36 36 + impl<'a> DnsSerialize<'a> for Request<'a> { 37 37 + type Error = DnsError; 38 38 + 39 39 + fn serialize<'b>(&self, writer: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 40 40 + writer.write(&self.id.to_be_bytes()); 41 41 + self.flags.serialize(writer).ok(); 42 42 + writer.write(&(self.queries.len() as u16).to_be_bytes()); 43 43 + writer.write(&ZERO_U16); 44 44 + writer.write(&ZERO_U16); 45 45 + writer.write(&ZERO_U16); 46 46 + 47 47 + self.queries 48 48 + .iter() 49 49 + .try_for_each(|query| query.serialize(writer)) 50 50 + } 51 51 + 52 52 + fn size(&self) -> usize { 53 53 + let total_query_size: usize = self.queries.iter().map(DnsSerialize::size).sum(); 54 54 + 55 55 + core::mem::size_of::<u16>() 56 56 + + self.flags.size() 57 57 + + (core::mem::size_of::<u16>() * 4) 58 58 + + total_query_size 59 59 + } 60 60 + } 61 61 + 62 62 + #[derive(Debug, PartialEq, Eq)] 63 63 + pub struct Response<'a> { 64 64 + pub id: u16, 65 65 + pub flags: Flags, 66 66 + pub queries: Vec<Query<'a>>, 67 67 + pub answers: Vec<Answer<'a>>, 68 68 + } 69 69 + 70 70 + impl<'a> DnsParse<'a> for Response<'a> { 71 71 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self> { 72 72 + let id = be_u16(input)?; 73 73 + let flags = Flags::parse(input, context)?; 74 74 + let qdcount = be_u16(input)?; 75 75 + let ancount = be_u16(input)?; 76 76 + let _nscount = be_u16(input)?; 77 77 + let _arcount = be_u16(input)?; 78 78 + 79 79 + let queries = (0..qdcount) 80 80 + .map(|_| Query::parse(input, context)) 81 81 + .collect::<Result<Vec<_>, _>>()?; 82 82 + 83 83 + let answers = (0..ancount) 84 84 + .map(|_| Answer::parse(input, context)) 85 85 + .collect::<Result<Vec<_>, _>>()?; 86 86 + 87 87 + Ok(Response { 88 88 + id, 89 89 + flags, 90 90 + queries, 91 91 + answers, 92 92 + }) 93 93 + } 94 94 + } 95 95 + 96 96 + impl<'a> DnsSerialize<'a> for Response<'a> { 97 97 + type Error = DnsError; 98 98 + 99 99 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error> { 100 100 + encoder.write(&self.id.to_be_bytes()); 101 101 + self.flags.serialize(encoder).ok(); 102 102 + encoder.write(&(self.queries.len() as u16).to_be_bytes()); 103 103 + encoder.write(&(self.answers.len() as u16).to_be_bytes()); 104 104 + encoder.write(&ZERO_U16); 105 105 + encoder.write(&ZERO_U16); 106 106 + 107 107 + self.queries 108 108 + .iter() 109 109 + .try_for_each(|query| query.serialize(encoder))?; 110 110 + self.answers 111 111 + .iter() 112 112 + .try_for_each(|answer| answer.serialize(encoder)) 113 113 + } 114 114 + 115 115 + fn size(&self) -> usize { 116 116 + let total_query_size: usize = self.queries.iter().map(DnsSerialize::size).sum(); 117 117 + let total_answer_size: usize = self.answers.iter().map(DnsSerialize::size).sum(); 118 118 + 119 119 + core::mem::size_of::<u16>() 120 120 + + self.flags.size() 121 121 + + (core::mem::size_of::<u16>() * 4) 122 122 + + total_query_size 123 123 + + total_answer_size 124 124 + } 125 125 + } 126 126 + 127 127 + #[cfg(feature = "defmt")] 128 128 + impl<'a> defmt::Format for Request<'a> { 129 129 + fn format(&self, fmt: defmt::Formatter) { 130 130 + defmt::write!( 131 131 + fmt, 132 132 + "Request {{ id: {}, flags: {:?}, queries: {:?} }}", 133 133 + self.id, 134 134 + self.flags, 135 135 + self.queries 136 136 + ); 137 137 + } 138 138 + } 139 139 + 140 140 + #[cfg(feature = "defmt")] 141 141 + impl<'a> defmt::Format for Response<'a> { 142 142 + fn format(&self, fmt: defmt::Formatter) { 143 143 + defmt::write!( 144 144 + fmt, 145 145 + "Response {{ id: {}, flags: {:?}, queries: {:?}, answers: {:?} }}", 146 146 + self.id, 147 147 + self.flags, 148 148 + self.queries, 149 149 + self.answers 150 150 + ); 151 151 + } 152 152 + } 153 153 + 154 154 + #[cfg(test)] 155 155 + mod tests { 156 156 + use alloc::vec; 157 157 + 158 158 + use super::*; 159 159 + use crate::dns::{ 160 160 + label::Label, 161 161 + query::QClass, 162 162 + records::{A, PTR, QType, Record, SRV, TXT}, 163 163 + }; 164 164 + use core::net::Ipv4Addr; 165 165 + 166 166 + #[test] 167 167 + fn parse_query() { 168 168 + let data = [ 169 169 + 0xAA, 0xAA, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x65, 170 170 + // example . com in label format 171 171 + 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x03, 0x63, 0x6F, 0x6D, 0x00, // 172 172 + // 173 173 + 0x00, 0x01, 0x00, 0x01, 174 174 + ]; 175 175 + 176 176 + let request = Request::parse(&mut data.as_slice(), data.as_slice()).unwrap(); 177 177 + 178 178 + assert_eq!(request.id, 0xAAAA); 179 179 + assert_eq!(request.flags.0, 0x0100); 180 180 + assert_eq!(request.queries.len(), 1); 181 181 + assert_eq!(request.queries[0].name, "example.com"); 182 182 + assert_eq!(request.queries[0].qtype, QType::A); 183 183 + assert_eq!(request.queries[0].qclass, QClass::IN); 184 184 + } 185 185 + 186 186 + #[test] 187 187 + fn parse_response() { 188 188 + let data = [ 189 189 + 0xAA, 0xAA, // transaction ID 190 190 + 0x81, 0x80, // flags 191 191 + 0x00, 0x01, // 1 question 192 192 + 0x00, 0x01, // 1 A-answer 193 193 + 0x00, 0x00, // no authority 194 194 + 0x00, 0x00, // no additional answers 195 195 + // example . com in label format 196 196 + 0x07, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x03, 0x63, 0x6F, 0x6D, 0x00, // 197 197 + // 198 198 + 0x00, 0x01, 0x00, 0x01, // 199 199 + // 200 200 + 0xC0, 0x0C, // ptr to question section 201 201 + // 202 202 + 0x00, 0x01, 0x00, 0x01, // A and IN 203 203 + // 204 204 + 0x00, 0x00, 0x00, 0x3C, // TTL 60 seconds 205 205 + // 206 206 + 0x00, 0x04, // length of address 207 207 + // IP address: 208 208 + 192, 168, 1, 3, 209 209 + ]; 210 210 + 211 211 + let response = Response::parse(&mut data.as_slice(), data.as_slice()).unwrap(); 212 212 + 213 213 + assert_eq!(response.id, 0xAAAA); 214 214 + assert_eq!(response.flags.0, 0x8180); 215 215 + assert_eq!(response.answers.len(), 1); 216 216 + assert_eq!(response.answers[0].name, "example.com"); 217 217 + assert_eq!(response.answers[0].atype, QType::A); 218 218 + assert_eq!(response.answers[0].aclass, QClass::IN); 219 219 + assert_eq!(response.answers[0].ttl, 60); 220 220 + if let Record::A(a) = &response.answers[0].record { 221 221 + assert_eq!(a.address, Ipv4Addr::new(192, 168, 1, 3)); 222 222 + } else { 223 223 + panic!("Expected A record"); 224 224 + } 225 225 + } 226 226 + 227 227 + #[test] 228 228 + fn parse_response_two_records() { 229 229 + let data = [ 230 230 + 0xAA, 0xAA, // 231 231 + 0x81, 0x80, // 232 232 + 0x00, 0x01, // 233 233 + 0x00, 0x02, // 234 234 + 0x00, 0x00, // 235 235 + 0x00, 0x00, // 236 236 + // example . com in label format 237 237 + 0x07, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x03, 0x63, 0x6F, 0x6D, 0x00, // 238 238 + // 239 239 + 0x00, 0x01, // query type 240 240 + 0x00, 0x01, // query class 241 241 + // 242 242 + 0xC0, 0x0C, // pointer 243 243 + 0x00, 0x01, // 244 244 + 0x00, 0x01, // 245 245 + 0x00, 0x00, 0x00, 0x3C, // ttl 60 seconds 246 246 + 0x00, 0x04, // length of A-record 247 247 + 0x5D, 0xB8, 0xD8, 0x22, // a-record 248 248 + // 249 249 + 0x07, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x03, 0x63, 0x6F, 0x6D, 0x00, // 250 250 + // 251 251 + 0x00, 0x10, // TXT 252 252 + 0x00, 0x01, // IN 253 253 + // 254 254 + 0x00, 0x00, 0x00, 0x3C, // ttl 60 seconds 255 255 + // 256 256 + 0x00, 0x10, // length of txt record 257 257 + // (len) "test txt record" 258 258 + 0x0F, 0x74, 0x65, 0x73, 0x74, 0x20, 0x74, 0x78, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6F, 0x72, 259 259 + 0x64, 260 260 + ]; 261 261 + 262 262 + let response = Response::parse(&mut data.as_slice(), data.as_slice()).unwrap(); 263 263 + 264 264 + assert_eq!(response.id, 0xAAAA); 265 265 + assert_eq!(response.flags.0, 0x8180); 266 266 + assert_eq!(response.answers.len(), 2); 267 267 + 268 268 + // First answer 269 269 + assert_eq!(response.answers[0].name, "example.com"); 270 270 + assert_eq!(response.answers[0].atype, QType::A); 271 271 + assert_eq!(response.answers[0].aclass, QClass::IN); 272 272 + assert_eq!(response.answers[0].ttl, 60); 273 273 + if let Record::A(a) = &response.answers[0].record { 274 274 + assert_eq!(a.address, Ipv4Addr::new(93, 184, 216, 34)); 275 275 + } else { 276 276 + panic!("Expected A record"); 277 277 + } 278 278 + 279 279 + // Second answer 280 280 + assert_eq!(response.answers[1].name, "example.com"); 281 281 + assert_eq!(response.answers[1].atype, QType::TXT); 282 282 + assert_eq!(response.answers[1].aclass, QClass::IN); 283 283 + assert_eq!(response.answers[1].ttl, 60); 284 284 + if let Record::TXT(txt) = &response.answers[1].record 285 285 + && let Some(&text) = txt.text.first() 286 286 + { 287 287 + assert_eq!(text, "test txt record"); 288 288 + } else { 289 289 + panic!("Expected TXT record"); 290 290 + } 291 291 + } 292 292 + 293 293 + #[test] 294 294 + fn parse_response_srv() { 295 295 + let data = [ 296 296 + // 297 297 + 0xAA, 0xAA, // id 298 298 + 0x81, 0x80, // flags 299 299 + 0x00, 0x01, // one question 300 300 + 0x00, 0x01, // one answer 301 301 + 0x00, 0x00, // no authority 302 302 + 0x00, 0x00, // no extra 303 303 + // 304 304 + 0x04, 0x5f, 0x73, 0x69, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x07, 0x65, 0x78, 0x61, 305 305 + 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // 306 306 + // 307 307 + 0x00, 0x21, // type SRV 308 308 + 0x00, 0x01, // IN 309 309 + // 310 310 + 0xc0, 0x0c, // 311 311 + // 312 312 + 0x00, 0x21, // SRV 313 313 + 0x00, 0x01, // IN 314 314 + 0x00, 0x00, 0x00, 0x3C, // ttl 60 315 315 + // 316 316 + 0x00, 0x19, // data len 317 317 + 0x00, 0x0A, // prio 318 318 + 0x00, 0x05, // weight 319 319 + 0x13, 0xC4, // PORT 320 320 + // 321 321 + 0x09, 0x73, 0x69, 0x70, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x07, 0x65, 0x78, 0x61, 322 322 + 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // 323 323 + ]; 324 324 + 325 325 + let response = Response::parse(&mut data.as_slice(), data.as_slice()).unwrap(); 326 326 + 327 327 + assert_eq!(response.id, 0xAAAA); 328 328 + assert_eq!(response.flags.0, 0x8180); 329 329 + assert_eq!(response.answers.len(), 1); 330 330 + 331 331 + // Answer 332 332 + assert_eq!(response.answers[0].name, "_sip._tcp.example.com"); 333 333 + assert_eq!(response.answers[0].atype, QType::SRV); 334 334 + assert_eq!(response.answers[0].aclass, QClass::IN); 335 335 + assert_eq!(response.answers[0].ttl, 60); 336 336 + let Record::SRV(srv) = &response.answers[0].record else { 337 337 + panic!("Expected SRV record"); 338 338 + }; 339 339 + 340 340 + assert_eq!(srv.priority, 10); 341 341 + assert_eq!(srv.weight, 5); 342 342 + assert_eq!(srv.port, 5060); 343 343 + assert_eq!(srv.target, "sipserver.example.com"); 344 344 + } 345 345 + 346 346 + #[test] 347 347 + fn parse_response_back_forth() { 348 348 + let data = [ 349 349 + 0, 0, // Transaction ID 350 350 + 132, 0, // Response, Authoritative Answer, No Recursion 351 351 + 0, 0, // 0 questions 352 352 + 0, 4, // 4 answers 353 353 + 0, 0, // 0 authority RRs 354 354 + 0, 0, // 0 additional RRs 355 355 + // _midiriff 356 356 + 9, 95, 109, 105, 100, 105, 114, 105, 102, 102, // 357 357 + // _udp 358 358 + 4, 95, 117, 100, 112, // 359 359 + // local 360 360 + 5, 108, 111, 99, 97, 108, // 361 361 + 0, // <end> 362 362 + // 363 363 + 0, 12, // PTR 364 364 + 0, 1, // Class IN 365 365 + 0, 0, 0, 120, // TTL 120 seconds 366 366 + 0, 10, // Data Length 10 367 367 + // pi35291 368 368 + 7, 112, 105, 51, 53, 50, 57, 49, // 369 369 + // 370 370 + 192, 12, // Pointer to _midirif._udp._local. 371 371 + // 372 372 + 192, 44, // Pointer to instace name: pi35291._midirif._udp._local. 373 373 + 0, 33, // SRV 374 374 + 128, 1, // IN (Cache flush bit set) 375 375 + 0, 0, 0, 120, // TTL 120 seconds 376 376 + 0, 11, // Data Length 11 377 377 + 0, 0, // Priority 0 378 378 + 0, 0, // Weight 0 379 379 + 137, 219, // Port 35291 380 380 + 2, 112, 105, // _pi 381 381 + 192, 27, // Pointer to: .local. 382 382 + // TXT (Empty) 383 383 + 192, 44, 0, 16, 128, 1, 0, 0, 17, 148, 0, 1, 0, 384 384 + // A (10.1.1.9) 385 385 + 192, 72, 0, 1, 128, 1, 0, 0, 0, 120, 0, 4, 10, 1, 1, 9, 386 386 + ]; 387 387 + 388 388 + let response = Response::parse(&mut data.as_slice(), data.as_slice()).unwrap(); 389 389 + 390 390 + assert_eq!(response.answers[0].name, "_midiriff._udp.local"); 391 391 + assert_eq!(response.answers[0].ttl, 120); 392 392 + let Record::PTR(ptr) = &response.answers[0].record else { 393 393 + panic!() 394 394 + }; 395 395 + assert_eq!(ptr.name, "pi35291._midiriff._udp.local"); 396 396 + 397 397 + let mut buffer = [0u8; 256]; 398 398 + let mut buffer = Encoder::new(&mut buffer); 399 399 + response.serialize(&mut buffer).unwrap(); 400 400 + 401 401 + let buffer = buffer.finish(); 402 402 + 403 403 + let response2 = Response::parse(&mut &buffer[..], buffer).unwrap(); 404 404 + 405 405 + assert_eq!(response, response2); 406 406 + } 407 407 + 408 408 + #[test] 409 409 + fn mdns_service_response() { 410 410 + let mut response = Response { 411 411 + id: 0x1234, 412 412 + flags: Flags::standard_response(), 413 413 + queries: Vec::new(), 414 414 + answers: Vec::new(), 415 415 + }; 416 416 + 417 417 + let query = Query { 418 418 + name: Label::from("_test._udp.local"), 419 419 + qtype: QType::PTR, 420 420 + qclass: QClass::IN, 421 421 + }; 422 422 + response.queries.push(query); 423 423 + 424 424 + let ptr_answer = Answer { 425 425 + name: Label::from("_test._udp.local"), 426 426 + atype: QType::PTR, 427 427 + aclass: QClass::IN, 428 428 + ttl: 4500, 429 429 + record: Record::PTR(PTR { 430 430 + name: Label::from("test-service._test._udp.local"), 431 431 + }), 432 432 + }; 433 433 + response.answers.push(ptr_answer); 434 434 + 435 435 + let srv_answer = Answer { 436 436 + name: Label::from("test-service._test._udp.local"), 437 437 + atype: QType::SRV, 438 438 + aclass: QClass::IN, 439 439 + ttl: 120, 440 440 + record: Record::SRV(SRV { 441 441 + priority: 0, 442 442 + weight: 0, 443 443 + port: 8080, 444 444 + target: Label::from("host.local"), 445 445 + }), 446 446 + }; 447 447 + response.answers.push(srv_answer); 448 448 + 449 449 + let txt_answer = Answer { 450 450 + name: Label::from("test-service._test._udp.local"), 451 451 + atype: QType::TXT, 452 452 + aclass: QClass::IN, 453 453 + ttl: 120, 454 454 + record: Record::TXT(TXT { 455 455 + text: vec!["path=/test"], 456 456 + }), 457 457 + }; 458 458 + response.answers.push(txt_answer); 459 459 + 460 460 + let a_answer = Answer { 461 461 + name: Label::from("host.local"), 462 462 + atype: QType::A, 463 463 + aclass: QClass::IN, 464 464 + ttl: 120, 465 465 + record: Record::A(A { 466 466 + address: Ipv4Addr::new(192, 168, 1, 100), 467 467 + }), 468 468 + }; 469 469 + response.answers.push(a_answer); 470 470 + 471 471 + let mut buffer = [0u8; 256]; 472 472 + let mut buffer = Encoder::new(&mut buffer); 473 473 + response.serialize(&mut buffer).unwrap(); 474 474 + 475 475 + let buffer = buffer.finish(); 476 476 + 477 477 + let parsed_response = Response::parse(&mut &buffer[..], buffer).unwrap(); 478 478 + 479 479 + assert_eq!(response, parsed_response); 480 480 + } 481 481 + }

+21

sachy-mdns/src/dns/traits.rs

··· 1 1 + use winnow::ModalResult; 2 2 + 3 3 + use crate::encoder::Encoder; 4 4 + 5 5 + pub trait DnsParse<'a>: Sized { 6 6 + fn parse(input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self>; 7 7 + } 8 8 + 9 9 + pub trait DnsParseKind<'a> { 10 10 + type Output; 11 11 + 12 12 + fn parse_kind(&self, input: &mut &'a [u8], context: &'a [u8]) -> ModalResult<Self::Output>; 13 13 + } 14 14 + 15 15 + pub trait DnsSerialize<'a> { 16 16 + type Error; 17 17 + 18 18 + fn serialize<'b>(&self, encoder: &mut Encoder<'a, 'b>) -> Result<(), Self::Error>; 19 19 + #[allow(dead_code)] 20 20 + fn size(&self) -> usize; 21 21 + }

+145

sachy-mdns/src/encoder.rs

··· 1 1 + use core::ops::Range; 2 2 + 3 3 + use alloc::collections::BTreeMap; 4 4 + 5 5 + use crate::dns::traits::DnsSerialize; 6 6 + 7 7 + pub(crate) const MAX_STR_LEN: u8 = !PTR_MASK; 8 8 + pub(crate) const PTR_MASK: u8 = 0b1100_0000; 9 9 + 10 10 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 11 11 + #[cfg_attr(feature = "defmt", derive(defmt::Format))] 12 12 + pub enum DnsError { 13 13 + LabelTooLong, 14 14 + InvalidTxt, 15 15 + Unsupported, 16 16 + } 17 17 + 18 18 + impl core::fmt::Display for DnsError { 19 19 + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 20 20 + match self { 21 21 + Self::LabelTooLong => f.write_str("Encoding Error: Segment too long"), 22 22 + Self::InvalidTxt => f.write_str("Encoding Error: TXT segment is invalid"), 23 23 + Self::Unsupported => f.write_str("Encoding Error: Unsupported Record Type"), 24 24 + } 25 25 + } 26 26 + } 27 27 + 28 28 + impl core::error::Error for DnsError {} 29 29 + 30 30 + #[derive(Debug)] 31 31 + pub struct Encoder<'a, 'b> { 32 32 + output: &'b mut [u8], 33 33 + position: usize, 34 34 + lookup: BTreeMap<&'a str, u16>, 35 35 + reservation: Option<usize>, 36 36 + } 37 37 + 38 38 + impl<'a, 'b> Encoder<'a, 'b> { 39 39 + pub const fn new(buffer: &'b mut [u8]) -> Self { 40 40 + Self { 41 41 + output: buffer, 42 42 + position: 0, 43 43 + lookup: BTreeMap::new(), 44 44 + reservation: None, 45 45 + } 46 46 + } 47 47 + 48 48 + /// Takes a payload and encodes it, consuming the encoder and yielding the resulting 49 49 + /// slice. 50 50 + pub fn encode<T, E>(mut self, payload: T) -> Result<&'b [u8], E> 51 51 + where 52 52 + E: core::error::Error, 53 53 + T: DnsSerialize<'a, Error = E>, 54 54 + { 55 55 + payload.serialize(&mut self)?; 56 56 + Ok(self.finish()) 57 57 + } 58 58 + 59 59 + pub(crate) fn finish(self) -> &'b [u8] { 60 60 + &self.output[..self.position] 61 61 + } 62 62 + 63 63 + fn increment(&mut self, amount: usize) { 64 64 + self.position += amount; 65 65 + } 66 66 + 67 67 + pub(crate) fn write_label(&mut self, mut label: &'a str) -> Result<(), DnsError> { 68 68 + loop { 69 69 + if let Some(pos) = self.get_label_position(label) { 70 70 + let [b1, b2] = u16::to_be_bytes(pos); 71 71 + self.write(&[b1 | PTR_MASK, b2]); 72 72 + return Ok(()); 73 73 + } 74 74 + 75 75 + let dot = label.find('.'); 76 76 + 77 77 + let end = dot.unwrap_or(label.len()); 78 78 + let segment = &label[..end]; 79 79 + let len = u8::try_from(segment.len()).map_err(|_| DnsError::LabelTooLong)?; 80 80 + 81 81 + if len > MAX_STR_LEN { 82 82 + return Err(DnsError::LabelTooLong); 83 83 + } 84 84 + 85 85 + self.store_label_position(label); 86 86 + self.write(&len.to_be_bytes()); 87 87 + self.write(segment.as_bytes()); 88 88 + 89 89 + match dot { 90 90 + Some(end) => { 91 91 + label = &label[end + 1..]; 92 92 + } 93 93 + None => { 94 94 + self.write(&[0]); 95 95 + return Ok(()); 96 96 + } 97 97 + } 98 98 + } 99 99 + } 100 100 + 101 101 + pub(crate) fn write(&mut self, bytes: &[u8]) { 102 102 + let len = bytes.len(); 103 103 + let end = self.position + len; 104 104 + self.output[self.position..end].copy_from_slice(bytes); 105 105 + self.increment(len); 106 106 + } 107 107 + 108 108 + fn get_label_position(&mut self, label: &str) -> Option<u16> { 109 109 + self.lookup.get(label).copied() 110 110 + } 111 111 + 112 112 + fn store_label_position(&mut self, label: &'a str) { 113 113 + self.lookup.insert(label, self.position as u16); 114 114 + } 115 115 + 116 116 + fn reserve_record_length(&mut self) { 117 117 + if self.reservation.is_none() { 118 118 + self.reservation = Some(self.position); 119 119 + self.increment(2); 120 120 + } 121 121 + } 122 122 + 123 123 + fn distance_from_reservation(&mut self) -> Option<(Range<usize>, u16)> { 124 124 + self.reservation 125 125 + .take() 126 126 + .map(|start| (start..(start + 2), (self.position - start - 2) as u16)) 127 127 + } 128 128 + 129 129 + fn write_record_length(&mut self) { 130 130 + if let Some((reservation, len)) = self.distance_from_reservation() { 131 131 + self.output[reservation].copy_from_slice(&len.to_be_bytes()); 132 132 + } 133 133 + } 134 134 + 135 135 + pub(crate) fn with_record_length<E, F>(&mut self, encoding_scope: F) -> Result<(), E> 136 136 + where 137 137 + E: core::error::Error, 138 138 + F: FnOnce(&mut Self) -> Result<(), E>, 139 139 + { 140 140 + self.reserve_record_length(); 141 141 + encoding_scope(self)?; 142 142 + self.write_record_length(); 143 143 + Ok(()) 144 144 + } 145 145 + }

+60

sachy-mdns/src/lib.rs

··· 1 1 + #![no_std] 2 2 + 3 3 + mod dns; 4 4 + pub(crate) mod encoder; 5 5 + pub mod server; 6 6 + mod service; 7 7 + mod state; 8 8 + 9 9 + extern crate alloc; 10 10 + 11 11 + use core::net::{Ipv4Addr, SocketAddrV4}; 12 12 + 13 13 + pub use crate::service::Service; 14 14 + pub use crate::state::MdnsAction; 15 15 + use crate::{dns::flags::Flags, server::Server, state::MdnsStateMachine}; 16 16 + 17 17 + /// Standard port for mDNS (5353). 18 18 + pub const MDNS_PORT: u16 = 5353; 19 19 + 20 20 + /// Standard IPv4 multicast address for mDNS (224.0.0.251). 21 21 + pub const GROUP_ADDR_V4: Ipv4Addr = Ipv4Addr::new(224, 0, 0, 251); 22 22 + pub const GROUP_SOCK_V4: SocketAddrV4 = SocketAddrV4::new(GROUP_ADDR_V4, MDNS_PORT); 23 23 + 24 24 + #[derive(Debug)] 25 25 + #[cfg_attr(feature = "defmt", derive(defmt::Format))] 26 26 + pub struct MdnsService { 27 27 + server: Server, 28 28 + state: MdnsStateMachine, 29 29 + } 30 30 + 31 31 + impl MdnsService { 32 32 + pub fn new(service: Service) -> Self { 33 33 + Self { 34 34 + server: Server::new(service), 35 35 + state: Default::default(), 36 36 + } 37 37 + } 38 38 + 39 39 + pub fn next_action(&mut self) -> MdnsAction { 40 40 + self.state.drive_next_action() 41 41 + } 42 42 + 43 43 + pub fn send_announcement<'buffer>(&self, outgoing: &'buffer mut [u8]) -> Option<&'buffer [u8]> { 44 44 + self.server.broadcast( 45 45 + server::ResponseKind::Announcement, 46 46 + Flags::standard_response(), 47 47 + 1, 48 48 + alloc::vec::Vec::new(), 49 49 + outgoing, 50 50 + ) 51 51 + } 52 52 + 53 53 + pub fn listen_for_queries<'buffer>( 54 54 + &mut self, 55 55 + incoming: &[u8], 56 56 + outgoing: &'buffer mut [u8], 57 57 + ) -> Option<&'buffer [u8]> { 58 58 + self.server.respond(incoming, outgoing) 59 59 + } 60 60 + }

+95

sachy-mdns/src/server.rs

··· 1 1 + use alloc::vec::Vec; 2 2 + use sachy_fmt::{error, info}; 3 3 + 4 4 + use crate::{ 5 5 + dns::{ 6 6 + flags::Flags, 7 7 + query::{QClass, Query}, 8 8 + records::QType, 9 9 + reqres::{Request, Response}, 10 10 + traits::DnsParse, 11 11 + }, 12 12 + encoder::Encoder, 13 13 + service::Service, 14 14 + }; 15 15 + 16 16 + pub(crate) enum ResponseKind { 17 17 + Announcement, 18 18 + QueryResponse(Vec<(QType, QClass)>), 19 19 + } 20 20 + 21 21 + #[derive(Debug)] 22 22 + #[cfg_attr(feature = "defmt", derive(defmt::Format))] 23 23 + pub(crate) struct Server { 24 24 + service: Service, 25 25 + } 26 26 + 27 27 + impl Server { 28 28 + pub(crate) fn new(service: Service) -> Self { 29 29 + Self { service } 30 30 + } 31 31 + 32 32 + pub(crate) fn broadcast<'a, 'b>( 33 33 + &self, 34 34 + response_kind: ResponseKind, 35 35 + flags: Flags, 36 36 + id: u16, 37 37 + queries: Vec<Query<'b>>, 38 38 + outgoing: &'a mut [u8], 39 39 + ) -> Option<&'a [u8]> { 40 40 + let answers: Vec<_> = match response_kind { 41 41 + ResponseKind::Announcement => self.service.as_answers(QClass::Multicast).collect(), 42 42 + ResponseKind::QueryResponse(valid) => valid 43 43 + .iter() 44 44 + .flat_map(|&(qtype, qclass)| match qtype { 45 45 + QType::A | QType::AAAA => self.service.ip_answer(qclass), 46 46 + QType::PTR => self.service.ptr_answer(qclass), 47 47 + QType::TXT => self.service.txt_answer(qclass), 48 48 + QType::SRV => self.service.srv_answer(qclass), 49 49 + QType::Any | QType::Unknown(_) => None, 50 50 + }) 51 51 + .collect(), 52 52 + }; 53 53 + 54 54 + if !answers.is_empty() { 55 55 + let res = Response { 56 56 + flags, 57 57 + id, 58 58 + queries, 59 59 + answers, 60 60 + }; 61 61 + 62 62 + info!("MDNS RESPONSE: {}", res); 63 63 + 64 64 + return Encoder::new(outgoing) 65 65 + .encode(res) 66 66 + .inspect_err(|err| error!("Encoder errored: {}", err)) 67 67 + .ok(); 68 68 + } 69 69 + 70 70 + None 71 71 + } 72 72 + 73 73 + pub(crate) fn respond<'a>(&self, incoming: &[u8], outgoing: &'a mut [u8]) -> Option<&'a [u8]> { 74 74 + Request::parse(&mut &incoming[..], incoming) 75 75 + .ok() 76 76 + .and_then(|req| { 77 77 + let valid_queries = req 78 78 + .queries 79 79 + .iter() 80 80 + .filter_map(|q| match q.qtype { 81 81 + QType::A | QType::AAAA | QType::TXT | QType::SRV => { 82 82 + (q.name == self.service.hostname()).then_some((q.qtype, q.qclass)) 83 83 + } 84 84 + QType::PTR => (q.name == self.service.service_type()).then_some((q.qtype, q.qclass)), 85 85 + QType::Any | QType::Unknown(_) => None, 86 86 + }).collect::<Vec<_>>(); 87 87 + 88 88 + if !valid_queries.is_empty() { 89 89 + self.broadcast(ResponseKind::QueryResponse(valid_queries), req.flags, req.id, req.queries, outgoing) 90 90 + } else { 91 91 + None 92 92 + } 93 93 + }) 94 94 + } 95 95 + }

+193

sachy-mdns/src/service.rs

··· 1 1 + use core::net::IpAddr; 2 2 + 3 3 + use alloc::{ 4 4 + string::{String, ToString}, 5 5 + vec::Vec, 6 6 + }; 7 7 + 8 8 + use crate::dns::{ 9 9 + label::Label, 10 10 + query::{Answer, QClass}, 11 11 + records::{A, AAAA, PTR, QType, Record, SRV, TXT}, 12 12 + }; 13 13 + 14 14 + #[derive(Debug, Default)] 15 15 + #[cfg_attr(feature = "defmt", derive(defmt::Format))] 16 16 + pub struct Service { 17 17 + service_type: String, 18 18 + instance: String, 19 19 + hostname: String, 20 20 + ip: Option<IpAddr>, 21 21 + port: u16, 22 22 + } 23 23 + 24 24 + impl Service { 25 25 + pub fn new( 26 26 + service_type: impl Into<String>, 27 27 + instance: impl Into<String>, 28 28 + hostname: impl Into<String>, 29 29 + ip: Option<IpAddr>, 30 30 + port: u16, 31 31 + ) -> Self { 32 32 + let service_type = service_type.into(); 33 33 + let mut instance = instance.into(); 34 34 + let mut hostname = hostname.into(); 35 35 + 36 36 + instance.push('.'); 37 37 + instance.push_str(&service_type); 38 38 + hostname.push_str(".local"); 39 39 + 40 40 + Self { 41 41 + service_type, 42 42 + instance, 43 43 + hostname, 44 44 + ip, 45 45 + port, 46 46 + } 47 47 + } 48 48 + 49 49 + pub fn service_type(&self) -> Label<'_> { 50 50 + Label::from(self.service_type.as_ref()) 51 51 + } 52 52 + 53 53 + pub fn instance(&self) -> Label<'_> { 54 54 + Label::from(self.instance.as_ref()) 55 55 + } 56 56 + 57 57 + pub fn hostname(&self) -> Label<'_> { 58 58 + Label::from(self.hostname.as_ref()) 59 59 + } 60 60 + 61 61 + pub fn ip(&self) -> Option<IpAddr> { 62 62 + self.ip 63 63 + } 64 64 + 65 65 + pub fn port(&self) -> u16 { 66 66 + self.port 67 67 + } 68 68 + 69 69 + pub(crate) fn ptr_answer(&self, aclass: QClass) -> Option<Answer<'_>> { 70 70 + Some(Answer { 71 71 + name: self.service_type(), 72 72 + atype: QType::PTR, 73 73 + aclass, 74 74 + ttl: 4500, 75 75 + record: Record::PTR(PTR { 76 76 + name: self.instance(), 77 77 + }), 78 78 + }) 79 79 + } 80 80 + 81 81 + pub(crate) fn srv_answer(&self, aclass: QClass) -> Option<Answer<'_>> { 82 82 + Some(Answer { 83 83 + name: self.instance(), 84 84 + atype: QType::SRV, 85 85 + aclass, 86 86 + ttl: 120, 87 87 + record: Record::SRV(SRV { 88 88 + priority: 0, 89 89 + weight: 0, 90 90 + port: self.port, 91 91 + target: self.hostname(), 92 92 + }), 93 93 + }) 94 94 + } 95 95 + 96 96 + pub(crate) fn txt_answer(&self, aclass: QClass) -> Option<Answer<'_>> { 97 97 + Some(Answer { 98 98 + name: self.instance(), 99 99 + atype: QType::TXT, 100 100 + aclass, 101 101 + ttl: 120, 102 102 + record: Record::TXT(TXT { text: Vec::new() }), 103 103 + }) 104 104 + } 105 105 + 106 106 + pub(crate) fn ip_answer(&self, aclass: QClass) -> Option<Answer<'_>> { 107 107 + self.ip().map(|address| match address { 108 108 + IpAddr::V4(address) => Answer { 109 109 + name: self.hostname(), 110 110 + atype: QType::A, 111 111 + aclass, 112 112 + ttl: 120, 113 113 + record: Record::A(A { address }), 114 114 + }, 115 115 + IpAddr::V6(address) => Answer { 116 116 + name: self.hostname(), 117 117 + atype: QType::AAAA, 118 118 + aclass, 119 119 + ttl: 120, 120 120 + record: Record::AAAA(AAAA { address }), 121 121 + }, 122 122 + }) 123 123 + } 124 124 + 125 125 + pub(crate) fn as_answers(&self, aclass: QClass) -> impl Iterator<Item = Answer<'_>> { 126 126 + self.ptr_answer(aclass) 127 127 + .into_iter() 128 128 + .chain(self.srv_answer(aclass)) 129 129 + .chain(self.txt_answer(aclass)) 130 130 + .chain(self.ip_answer(aclass)) 131 131 + } 132 132 + 133 133 + #[allow(dead_code)] 134 134 + pub(crate) fn from_answers(answers: &[Answer<'_>]) -> Vec<Self> { 135 135 + let mut output = Vec::new(); 136 136 + 137 137 + // Step 1: Process PTR records 138 138 + for answer in answers { 139 139 + if let Record::PTR(ptr) = &answer.record { 140 140 + let instance = ptr.name.to_string(); 141 141 + let service_type = answer.name.to_string(); 142 142 + output.push(Self { 143 143 + service_type, 144 144 + instance, 145 145 + ..Default::default() 146 146 + }); 147 147 + } 148 148 + } 149 149 + 150 150 + // Step 2: Process SRV records, A and AAAA records and merge data 151 151 + for answer in answers { 152 152 + match &answer.record { 153 153 + Record::SRV(srv) => { 154 154 + if let Some(stub) = output 155 155 + .iter_mut() 156 156 + .find(|stub| answer.name == stub.instance.as_ref()) 157 157 + { 158 158 + stub.hostname = srv.target.to_string(); 159 159 + stub.port = srv.port; 160 160 + } 161 161 + } 162 162 + Record::A(a) => { 163 163 + if let Some(stub) = output 164 164 + .iter_mut() 165 165 + .find(|stub| answer.name == stub.hostname.as_ref()) 166 166 + { 167 167 + stub.ip = Some(IpAddr::V4(a.address)); 168 168 + } 169 169 + } 170 170 + Record::AAAA(aaaa) => { 171 171 + if let Some(stub) = output 172 172 + .iter_mut() 173 173 + .find(|stub| answer.name == stub.hostname.as_ref()) 174 174 + { 175 175 + stub.ip = Some(IpAddr::V6(aaaa.address)); 176 176 + } 177 177 + } 178 178 + _ => {} 179 179 + } 180 180 + } 181 181 + 182 182 + // Final step: Retain only complete services 183 183 + output.retain(|stub| { 184 184 + !stub.service_type.is_empty() 185 185 + && !stub.instance.is_empty() 186 186 + && !stub.hostname.is_empty() 187 187 + && stub.ip.is_some() 188 188 + && stub.port != 0 189 189 + }); 190 190 + 191 191 + output 192 192 + } 193 193 + }

+100

sachy-mdns/src/state.rs

··· 1 1 + use embassy_time::{Duration, Instant}; 2 2 + use sachy_fmt::{debug, unwrap}; 3 3 + 4 4 + #[derive(Debug, Default)] 5 5 + #[cfg_attr(feature = "defmt", derive(defmt::Format))] 6 6 + pub(crate) enum MdnsStateMachine { 7 7 + #[default] 8 8 + Start, 9 9 + Announce { 10 10 + last_sent: Instant, 11 11 + }, 12 12 + ListenFor { 13 13 + last_sent: Instant, 14 14 + timeout: Duration, 15 15 + }, 16 16 + WaitFor { 17 17 + last_sent: Instant, 18 18 + duration: Duration, 19 19 + }, 20 20 + } 21 21 + 22 22 + impl MdnsStateMachine { 23 23 + /// Set the state to announced, if we have timed out the listening period and need 24 24 + /// to announce, or if we received a query while listening and have sent a response. 25 25 + pub(crate) fn announced(&mut self) { 26 26 + *self = Self::Announce { 27 27 + last_sent: Instant::now(), 28 28 + }; 29 29 + } 30 30 + 31 31 + fn next_state(&mut self) { 32 32 + match self { 33 33 + Self::Start => self.announced(), 34 34 + &mut Self::Announce { last_sent } => { 35 35 + let duration_since = last_sent.elapsed(); 36 36 + let duration = Duration::from_secs(1) - duration_since; 37 37 + 38 38 + *self = Self::WaitFor { 39 39 + last_sent, 40 40 + duration, 41 41 + }; 42 42 + } 43 43 + &mut Self::ListenFor { last_sent, .. } => { 44 44 + let duration_since = last_sent.elapsed(); 45 45 + let time_limit = Duration::from_secs(120); 46 46 + 47 47 + if duration_since >= time_limit { 48 48 + self.announced(); 49 49 + } else { 50 50 + let timeout = time_limit - duration_since; 51 51 + *self = Self::ListenFor { last_sent, timeout }; 52 52 + } 53 53 + } 54 54 + &mut Self::WaitFor { last_sent, .. } => { 55 55 + let duration_since = last_sent.elapsed(); 56 56 + let time_limit = Duration::from_secs(120); 57 57 + let timeout = time_limit - duration_since; 58 58 + 59 59 + *self = Self::ListenFor { last_sent, timeout }; 60 60 + } 61 61 + } 62 62 + } 63 63 + 64 64 + pub(crate) fn drive_next_action(&mut self) -> MdnsAction { 65 65 + self.next_state(); 66 66 + unwrap!(MdnsAction::try_from(self)) 67 67 + } 68 68 + } 69 69 + 70 70 + #[derive(Debug)] 71 71 + #[cfg_attr(feature = "defmt", derive(defmt::Format))] 72 72 + pub enum MdnsAction { 73 73 + Announce, 74 74 + ListenFor { timeout: Duration }, 75 75 + WaitFor { duration: Duration }, 76 76 + } 77 77 + 78 78 + impl TryFrom<&mut MdnsStateMachine> for MdnsAction { 79 79 + type Error = MdnsStateMachine; 80 80 + 81 81 + fn try_from(value: &mut MdnsStateMachine) -> Result<Self, Self::Error> { 82 82 + match value { 83 83 + // We should start in this state, but never remain nor return to it when 84 84 + // executing our state machine event loop. 85 85 + MdnsStateMachine::Start => Err(MdnsStateMachine::Start), 86 86 + MdnsStateMachine::Announce { .. } => { 87 87 + debug!("ANNOUNCE"); 88 88 + Ok(Self::Announce) 89 89 + } 90 90 + &mut MdnsStateMachine::ListenFor { timeout, .. } => { 91 91 + debug!("LISTEN FOR {}ms", timeout.as_millis()); 92 92 + Ok(Self::ListenFor { timeout }) 93 93 + } 94 94 + &mut MdnsStateMachine::WaitFor { duration, .. } => { 95 95 + debug!("WAIT FOR {}ms", duration.as_millis()); 96 96 + Ok(Self::WaitFor { duration }) 97 97 + } 98 98 + } 99 99 + } 100 100 + }