commit 5172f3e7ba897ac4665ba3f943d422dd85a53262 · sachy.dev/sachy-embed-core

+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]]

     
···

       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
       +
       

     

       1132
       1132
       +
       [[package]]

     

       1123
       1133
        
       name = "sachy-shtc3"

     

       1124
       1134
        
       version = "0.1.0"

     

       1125
       1135
        
       dependencies = [

     
···

       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]]

     
···

       1482
       1492
        
       version = "0.52.6"

     

       1483
       1493
        
       source = "registry+https://github.com/rust-lang/crates.io-index"

     

       1484
       1494
        
       checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

     

       1495
       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"

     

       1485
       1501
        
       

     

       1486
       1502
        
       [[package]]

     

       1487
       1503
        
       name = "wit-bindgen"

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"] }

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
       +
       }

+512

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,

     

       149
       149
       +
                               DnsError::LabelTooLong,

     

       150
       150
       +
                           )));

     

       151
       151
       +
                       }

     

       152
       152
       +
       

     

       153
       153
       +
                       let segment = take(len).try_map(core::str::from_utf8).parse_next(input)?;

     

       154
       154
       +
       

     

       155
       155
       +
                       Ok(Self::String(segment))

     

       156
       156
       +
                   }

     

       157
       157
       +
               }

     

       158
       158
       +
           }

     

       159
       159
       +
       

     

       160
       160
       +
           /// ## Safety

     

       161
       161
       +
           /// The caller upholds that this function is not called when parsing from newly received data. Data that

     

       162
       162
       +
           /// has yet to be determined to be a valid [`Label`] should be parsed and validated with [`Label::parse`],

     

       163
       163
       +
           /// and that the entire data/context has been validated, not just a portion of it.

     

       164
       164
       +
           #[inline]

     

       165
       165
       +
           unsafe fn parse_unchecked(input: &'a [u8]) -> Option<Self> {

     

       166
       166
       +
               input.split_first().map(|(b1, input)| match *b1 {

     

       167
       167
       +
                   0 => Self::Empty,

     

       168
       168
       +
                   b1 if b1 & PTR_MASK == PTR_MASK => {

     

       169
       169
       +
                       // SAFETY: The caller has already validated that a second byte is available for a

     

       170
       170
       +
                       // Pointer segment.

     

       171
       171
       +
                       let b2 = unsafe { *input.get_unchecked(0) };

     

       172
       172
       +
       

     

       173
       173
       +
                       let ptr = u16::from_be_bytes([b1 & !PTR_MASK, b2]);

     

       174
       174
       +
       

     

       175
       175
       +
                       Self::Pointer(ptr)

     

       176
       176
       +
                   }

     

       177
       177
       +
                   len => {

     

       178
       178
       +
                       // SAFETY: The caller has validated that this length value is correct and will only

     

       179
       179
       +
                       // access within the bounds of the provided slice.

     

       180
       180
       +
                       let segment = unsafe { input.get_unchecked(0..(len as usize)) };

     

       181
       181
       +
                       // SAFETY: The caller has upheld the validity of the bytes as valid UTF-8 once before.

     

       182
       182
       +
                       let segment = unsafe { core::str::from_utf8_unchecked(segment) };

     

       183
       183
       +
       

     

       184
       184
       +
                       Self::String(segment)

     

       185
       185
       +
                   }

     

       186
       186
       +
               })

     

       187
       187
       +
           }

     

       188
       188
       +
       

     

       189
       189
       +
           fn as_str(&self) -> Option<&'a str> {

     

       190
       190
       +
               match self {

     

       191
       191
       +
                   Self::String(label) => Some(*label),

     

       192
       192
       +
                   _ => None,

     

       193
       193
       +
               }

     

       194
       194
       +
           }

     

       195
       195
       +
       }

     

       196
       196
       +
       

     

       197
       197
       +
       pub struct LabelSegmentBytesIter<'a> {

     

       198
       198
       +
           context: &'a [u8],

     

       199
       199
       +
           start: usize,

     

       200
       200
       +
       }

     

       201
       201
       +
       

     

       202
       202
       +
       impl<'a> LabelSegmentBytesIter<'a> {

     

       203
       203
       +
           pub(crate) fn new(context: &'a [u8], start: usize) -> Self {

     

       204
       204
       +
               Self { context, start }

     

       205
       205
       +
           }

     

       206
       206
       +
       }

     

       207
       207
       +
       

     

       208
       208
       +
       impl<'a> Iterator for LabelSegmentBytesIter<'a> {

     

       209
       209
       +
           type Item = LabelSegment<'a>;

     

       210
       210
       +
       

     

       211
       211
       +
           fn next(&mut self) -> Option<Self::Item> {

     

       212
       212
       +
               loop {

     

       213
       213
       +
                   let view = &self.context[self.start..];

     

       214
       214
       +
       

     

       215
       215
       +
                   // SAFETY: The segment has already been validated, so they should be all valid variants and UTF-8 bytes

     

       216
       216
       +
                   let segment = unsafe { LabelSegment::parse_unchecked(view)? };

     

       217
       217
       +
       

     

       218
       218
       +
                   match segment {

     

       219
       219
       +
                       LabelSegment::String(label) => {

     

       220
       220
       +
                           self.start = self.start.saturating_add(label.len() + 1);

     

       221
       221
       +
                           return Some(segment);

     

       222
       222
       +
                       }

     

       223
       223
       +
                       LabelSegment::Pointer(ptr) => {

     

       224
       224
       +
                           self.start = ptr as usize;

     

       225
       225
       +
                       }

     

       226
       226
       +
                       LabelSegment::Empty => {

     

       227
       227
       +
                           // Set the index offset to be len() so that the view is empty and terminates the loop

     

       228
       228
       +
                           self.start = self.context.len();

     

       229
       229
       +
                           return Some(LabelSegment::Empty);

     

       230
       230
       +
                       }

     

       231
       231
       +
                   }

     

       232
       232
       +
               }

     

       233
       233
       +
           }

     

       234
       234
       +
       }

     

       235
       235
       +
       

     

       236
       236
       +
       impl<'a> LabelRepr<'a> {

     

       237
       237
       +
           fn iter(&self) -> impl Iterator<Item = LabelSegment<'a>> {

     

       238
       238
       +
               match *self {

     

       239
       239
       +
                   LabelRepr::Bytes { context, start, .. } => {

     

       240
       240
       +
                       Either::A(LabelSegmentBytesIter::new(context, start))

     

       241
       241
       +
                   }

     

       242
       242
       +
                   LabelRepr::Str(view) => Either::B(

     

       243
       243
       +
                       view.split('.')

     

       244
       244
       +
                           .map(LabelSegment::String)

     

       245
       245
       +
                           .chain(Some(LabelSegment::Empty)),

     

       246
       246
       +
                   ),

     

       247
       247
       +
               }

     

       248
       248
       +
           }

     

       249
       249
       +
       }

     

       250
       250
       +
       

     

       251
       251
       +
       impl fmt::Debug for Label<'_> {

     

       252
       252
       +
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       253
       253
       +
               struct LabelFmt<'a>(&'a Label<'a>);

     

       254
       254
       +
       

     

       255
       255
       +
               impl fmt::Debug for LabelFmt<'_> {

     

       256
       256
       +
                   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       257
       257
       +
                       fmt::Display::fmt(self.0, f)

     

       258
       258
       +
                   }

     

       259
       259
       +
               }

     

       260
       260
       +
       

     

       261
       261
       +
               f.debug_tuple("Label").field(&LabelFmt(self)).finish()

     

       262
       262
       +
           }

     

       263
       263
       +
       }

     

       264
       264
       +
       

     

       265
       265
       +
       impl fmt::Display for Label<'_> {

     

       266
       266
       +
           fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

     

       267
       267
       +
               let mut names = self.names();

     

       268
       268
       +
       

     

       269
       269
       +
               if let Some(name) = names.next() {

     

       270
       270
       +
                   f.write_str(name)?;

     

       271
       271
       +
       

     

       272
       272
       +
                   names.try_for_each(|name| {

     

       273
       273
       +
                       f.write_str(".")?;

     

       274
       274
       +
                       f.write_str(name)

     

       275
       275
       +
                   })

     

       276
       276
       +
               } else {

     

       277
       277
       +
                   Ok(())

     

       278
       278
       +
               }

     

       279
       279
       +
           }

     

       280
       280
       +
       }

     

       281
       281
       +
       

     

       282
       282
       +
       impl<'a, 'b> PartialEq<Label<'a>> for Label<'b> {

     

       283
       283
       +
           fn eq(&self, other: &Label<'a>) -> bool {

     

       284
       284
       +
               self.segments().eq(other.segments())

     

       285
       285
       +
           }

     

       286
       286
       +
       }

     

       287
       287
       +
       

     

       288
       288
       +
       impl Eq for Label<'_> {}

     

       289
       289
       +
       

     

       290
       290
       +
       impl PartialEq<&str> for Label<'_> {

     

       291
       291
       +
           fn eq(&self, other: &&str) -> bool {

     

       292
       292
       +
               let mut self_iter = self.names();

     

       293
       293
       +
               let mut other_iter = other.split('.');

     

       294
       294
       +
       

     

       295
       295
       +
               loop {

     

       296
       296
       +
                   match (self_iter.next(), other_iter.next()) {

     

       297
       297
       +
                       (Some(self_part), Some(other_part)) => {

     

       298
       298
       +
                           if self_part != other_part {

     

       299
       299
       +
                               return false;

     

       300
       300
       +
                           }

     

       301
       301
       +
                       }

     

       302
       302
       +
                       (None, None) => return true,

     

       303
       303
       +
                       _ => return false,

     

       304
       304
       +
                   }

     

       305
       305
       +
               }

     

       306
       306
       +
           }

     

       307
       307
       +
       }

     

       308
       308
       +
       

     

       309
       309
       +
       #[cfg(feature = "defmt")]

     

       310
       310
       +
       impl defmt::Format for Label<'_> {

     

       311
       311
       +
           fn format(&self, fmt: defmt::Formatter) {

     

       312
       312
       +
               defmt::write!(fmt, "Label(");

     

       313
       313
       +
               let mut iter = self.names();

     

       314
       314
       +
               if let Some(first) = iter.next() {

     

       315
       315
       +
                   defmt::write!(fmt, "{}", first);

     

       316
       316
       +
       

     

       317
       317
       +
                   iter.for_each(|part| defmt::write!(fmt, ".{}", part));

     

       318
       318
       +
               }

     

       319
       319
       +
               defmt::write!(fmt, ")");

     

       320
       320
       +
           }

     

       321
       321
       +
       }

     

       322
       322
       +
       

     

       323
       323
       +
       /// One iterator or another.

     

       324
       324
       +
       enum Either<A, B> {

     

       325
       325
       +
           A(A),

     

       326
       326
       +
           B(B),

     

       327
       327
       +
       }

     

       328
       328
       +
       

     

       329
       329
       +
       impl<A: Iterator, Other: Iterator<Item = A::Item>> Iterator for Either<A, Other> {

     

       330
       330
       +
           type Item = A::Item;

     

       331
       331
       +
       

     

       332
       332
       +
           fn next(&mut self) -> Option<Self::Item> {

     

       333
       333
       +
               match self {

     

       334
       334
       +
                   Either::A(a) => a.next(),

     

       335
       335
       +
                   Either::B(b) => b.next(),

     

       336
       336
       +
               }

     

       337
       337
       +
           }

     

       338
       338
       +
       

     

       339
       339
       +
           fn size_hint(&self) -> (usize, Option<usize>) {

     

       340
       340
       +
               match self {

     

       341
       341
       +
                   Either::A(a) => a.size_hint(),

     

       342
       342
       +
                   Either::B(b) => b.size_hint(),

     

       343
       343
       +
               }

     

       344
       344
       +
           }

     

       345
       345
       +
       

     

       346
       346
       +
           fn fold<B, F>(self, init: B, f: F) -> B

     

       347
       347
       +
           where

     

       348
       348
       +
               Self: Sized,

     

       349
       349
       +
               F: FnMut(B, Self::Item) -> B,

     

       350
       350
       +
           {

     

       351
       351
       +
               match self {

     

       352
       352
       +
                   Either::A(a) => a.fold(init, f),

     

       353
       353
       +
                   Either::B(b) => b.fold(init, f),

     

       354
       354
       +
               }

     

       355
       355
       +
           }

     

       356
       356
       +
       }

     

       357
       357
       +
       

     

       358
       358
       +
       #[cfg(test)]

     

       359
       359
       +
       mod test {

     

       360
       360
       +
           use super::*;

     

       361
       361
       +
       

     

       362
       362
       +
           #[test]

     

       363
       363
       +
           fn segments_iter_test() {

     

       364
       364
       +
               let label: Label<'static> = Label::from("_service._udp.local");

     

       365
       365
       +
               let mut segments = label.segments();

     

       366
       366
       +
       

     

       367
       367
       +
               assert_eq!(segments.next(), Some(LabelSegment::String("_service")));

     

       368
       368
       +
               assert_eq!(segments.next(), Some(LabelSegment::String("_udp")));

     

       369
       369
       +
               assert_eq!(segments.next(), Some(LabelSegment::String("local")));

     

       370
       370
       +
               assert_eq!(segments.next(), Some(LabelSegment::Empty));

     

       371
       371
       +
               assert_eq!(segments.next(), None);

     

       372
       372
       +
       

     

       373
       373
       +
               // example.com with a pointer to the start

     

       374
       374
       +
               let data = b"\x07example\x03com\x00\xC0\x00";

     

       375
       375
       +
               let context = &data[..];

     

       376
       376
       +
               // The data here is entirely valid, even though we parse only a portion of it.

     

       377
       377
       +
               let label = Label::parse(&mut &data[13..], context).unwrap();

     

       378
       378
       +
       

     

       379
       379
       +
               let mut segments = label.segments();

     

       380
       380
       +
               assert_eq!(segments.next(), Some(LabelSegment::String("example")));

     

       381
       381
       +
               assert_eq!(segments.next(), Some(LabelSegment::String("com")));

     

       382
       382
       +
               assert_eq!(segments.next(), Some(LabelSegment::Empty));

     

       383
       383
       +
               assert_eq!(segments.next(), None);

     

       384
       384
       +
           }

     

       385
       385
       +
       

     

       386
       386
       +
           #[test]

     

       387
       387
       +
           fn names_iter_test() {

     

       388
       388
       +
               let label: Label<'static> = Label::from("_service._udp.local");

     

       389
       389
       +
               let mut names = label.names();

     

       390
       390
       +
       

     

       391
       391
       +
               assert_eq!(names.next(), Some("_service"));

     

       392
       392
       +
               assert_eq!(names.next(), Some("_udp"));

     

       393
       393
       +
               assert_eq!(names.next(), Some("local"));

     

       394
       394
       +
               assert_eq!(names.next(), None);

     

       395
       395
       +
       

     

       396
       396
       +
               let data = b"\x07example\x03com\x00\xC0\x00";

     

       397
       397
       +
               let context = &data[..];

     

       398
       398
       +
               // The data here is entirely valid, even though we parse only a portion of it.

     

       399
       399
       +
               let label = Label::parse(&mut &data[13..], context).unwrap();

     

       400
       400
       +
       

     

       401
       401
       +
               let mut names = label.names();

     

       402
       402
       +
               assert_eq!(names.next(), Some("example"));

     

       403
       403
       +
               assert_eq!(names.next(), Some("com"));

     

       404
       404
       +
               assert_eq!(names.next(), None);

     

       405
       405
       +
           }

     

       406
       406
       +
       

     

       407
       407
       +
           #[test]

     

       408
       408
       +
           fn serialize_str_label() {

     

       409
       409
       +
               let label: Label<'static> = Label::from("_service._udp.local");

     

       410
       410
       +
               let mut buffer = [0u8; 256];

     

       411
       411
       +
               let mut buffer = Encoder::new(&mut buffer);

     

       412
       412
       +
               label.serialize(&mut buffer).unwrap();

     

       413
       413
       +
               assert_eq!(buffer.finish(), b"\x08_service\x04_udp\x05local\x00");

     

       414
       414
       +
           }

     

       415
       415
       +
       

     

       416
       416
       +
           #[test]

     

       417
       417
       +
           fn serialize_compressed_str_label() {

     

       418
       418
       +
               let label: Label<'static> = Label::from("_service._udp.local");

     

       419
       419
       +
               let label2: Label<'static> = Label::from("other._udp.local");

     

       420
       420
       +
               let mut buffer = [0u8; 256];

     

       421
       421
       +
               let mut buffer = Encoder::new(&mut buffer);

     

       422
       422
       +
               label.serialize(&mut buffer).unwrap();

     

       423
       423
       +
               label2.serialize(&mut buffer).unwrap();

     

       424
       424
       +
               assert_eq!(

     

       425
       425
       +
                   buffer.finish(),

     

       426
       426
       +
                   b"\x08_service\x04_udp\x05local\x00\x05other\xC0\x09"

     

       427
       427
       +
               );

     

       428
       428
       +
           }

     

       429
       429
       +
       

     

       430
       430
       +
           #[test]

     

       431
       431
       +
           fn round_trip_compressed_str_label() {

     

       432
       432
       +
               let label: Label<'static> = Label::from("_service._udp.local");

     

       433
       433
       +
               let label2: Label<'static> = Label::from("other._udp.local");

     

       434
       434
       +
               let mut buffer = [0u8; 256];

     

       435
       435
       +
               let mut buffer = Encoder::new(&mut buffer);

     

       436
       436
       +
               label.serialize(&mut buffer).unwrap();

     

       437
       437
       +
               label2.serialize(&mut buffer).unwrap();

     

       438
       438
       +
               let context = buffer.finish();

     

       439
       439
       +
               assert_eq!(

     

       440
       440
       +
                   context,

     

       441
       441
       +
                   b"\x08_service\x04_udp\x05local\x00\x05other\xC0\x09"

     

       442
       442
       +
               );

     

       443
       443
       +
               let view = &mut &context[..];

     

       444
       444
       +
       

     

       445
       445
       +
               let parsed_label = Label::parse(view, context).unwrap();

     

       446
       446
       +
               let parsed_label2 = Label::parse(view, context).unwrap();

     

       447
       447
       +
       

     

       448
       448
       +
               let parsed_label_count = parsed_label.segments().count();

     

       449
       449
       +
               let parsed_label2_count = parsed_label2.segments().count();

     

       450
       450
       +
       

     

       451
       451
       +
               // Both have same amount of segments.

     

       452
       452
       +
               assert_eq!(parsed_label_count, parsed_label2_count);

     

       453
       453
       +
       

     

       454
       454
       +
               assert_eq!(parsed_label, label);

     

       455
       455
       +
               assert_eq!(parsed_label2, label2);

     

       456
       456
       +
           }

     

       457
       457
       +
       

     

       458
       458
       +
           #[test]

     

       459
       459
       +
           fn label_byte_repr_serialization_quick_path() {

     

       460
       460
       +
               let data = b"\x07example\x03com\x00\xC0\x00";

     

       461
       461
       +
               let context = &data[..];

     

       462
       462
       +
               // The data here is entirely valid, even though we parse only a portion of it.

     

       463
       463
       +
               let label = Label::parse(&mut &data[13..], context).unwrap();

     

       464
       464
       +
       

     

       465
       465
       +
               let mut buffer = [0u8; 256];

     

       466
       466
       +
               let mut buffer = Encoder::new(&mut buffer);

     

       467
       467
       +
               label.serialize(&mut buffer).unwrap();

     

       468
       468
       +
               // If the original Label is just a pointer, the new output will be a pointer, assuming

     

       469
       469
       +
               // the original data is also present in the output

     

       470
       470
       +
               assert_eq!(buffer.finish(), b"\xC0\x00");

     

       471
       471
       +
           }

     

       472
       472
       +
       

     

       473
       473
       +
           #[test]

     

       474
       474
       +
           fn parse_and_eq_created_label() {

     

       475
       475
       +
               let data = b"\x07example\x03com\x00\xC0\x00";

     

       476
       476
       +
               let context = &data[..];

     

       477
       477
       +
       

     

       478
       478
       +
               // The data here is entirely valid, even though we parse only a portion of it.

     

       479
       479
       +
               let parsed_label = Label::parse(&mut &data[13..], context).unwrap();

     

       480
       480
       +
       

     

       481
       481
       +
               let created_label = Label::from("example.com");

     

       482
       482
       +
       

     

       483
       483
       +
               assert_eq!(parsed_label, created_label);

     

       484
       484
       +
           }

     

       485
       485
       +
       

     

       486
       486
       +
           #[test]

     

       487
       487
       +
           fn parse_and_eq_label_with_str() {

     

       488
       488
       +
               let data = b"\x07example\x03com\x00";

     

       489
       489
       +
               let context = &data[..];

     

       490
       490
       +
       

     

       491
       491
       +
               let parsed_label = Label::parse(&mut &data[..], context).unwrap();

     

       492
       492
       +
       

     

       493
       493
       +
               assert_eq!(parsed_label, "example.com");

     

       494
       494
       +
           }

     

       495
       495
       +
       

     

       496
       496
       +
           #[test]

     

       497
       497
       +
           fn parse_ptr_label_and_eq_with_str() {

     

       498
       498
       +
               let data = b"\x07example\x03com\x00\xC0\x00";

     

       499
       499
       +
               let context = &data[..];

     

       500
       500
       +
       

     

       501
       501
       +
               // The data here is entirely valid, even though we parse only a portion of it.

     

       502
       502
       +
               let parsed_label = Label::parse(&mut &data[13..], context).unwrap();

     

       503
       503
       +
       

     

       504
       504
       +
               assert_eq!(parsed_label, "example.com");

     

       505
       505
       +
           }

     

       506
       506
       +
       

     

       507
       507
       +
           #[test]

     

       508
       508
       +
           fn label_new_without_dot_is_not_empty() {

     

       509
       509
       +
               let label: Label = Label::from("example");

     

       510
       510
       +
               assert!(!label.is_empty());

     

       511
       511
       +
           }

     

       512
       512
       +
       }

+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
       +
       }

+483

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
       +
               #[rustfmt::skip]

     

       230
       230
       +
               let data = [

     

       231
       231
       +
                   0xAA, 0xAA, //

     

       232
       232
       +
                   0x81, 0x80, //

     

       233
       233
       +
                   0x00, 0x01, //

     

       234
       234
       +
                   0x00, 0x02, //

     

       235
       235
       +
                   0x00, 0x00, //

     

       236
       236
       +
                   0x00, 0x00, //

     

       237
       237
       +
                   // example . com in label format

     

       238
       238
       +
                   0x07, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x03, 0x63, 0x6F, 0x6D, 0x00, //

     

       239
       239
       +
                   //

     

       240
       240
       +
                   0x00, 0x01, // query type

     

       241
       241
       +
                   0x00, 0x01, // query class

     

       242
       242
       +
                   //

     

       243
       243
       +
                   0xC0, 0x0C, // pointer

     

       244
       244
       +
                   0x00, 0x01, //

     

       245
       245
       +
                   0x00, 0x01, //

     

       246
       246
       +
                   0x00, 0x00, 0x00, 0x3C, // ttl 60 seconds

     

       247
       247
       +
                   0x00, 0x04, // length of A-record

     

       248
       248
       +
                   0x5D, 0xB8, 0xD8, 0x22, // a-record

     

       249
       249
       +
                   //

     

       250
       250
       +
                   0x07, 0x65, 0x78, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x03, 0x63, 0x6F, 0x6D, 0x00, //

     

       251
       251
       +
                   //

     

       252
       252
       +
                   0x00, 0x10, // TXT

     

       253
       253
       +
                   0x00, 0x01, // IN

     

       254
       254
       +
                   //

     

       255
       255
       +
                   0x00, 0x00, 0x00, 0x3C, // ttl 60 seconds

     

       256
       256
       +
                   //

     

       257
       257
       +
                   0x00, 0x10, // length of txt record

     

       258
       258
       +
                   // (len) "test txt record"

     

       259
       259
       +
                   0x0F, 0x74, 0x65, 0x73, 0x74, 0x20, 0x74, 0x78, 0x74, 0x20, 0x72, 0x65, 0x63, 0x6F, 0x72,

     

       260
       260
       +
                   0x64,

     

       261
       261
       +
               ];

     

       262
       262
       +
       

     

       263
       263
       +
               let response = Response::parse(&mut data.as_slice(), data.as_slice()).unwrap();

     

       264
       264
       +
       

     

       265
       265
       +
               assert_eq!(response.id, 0xAAAA);

     

       266
       266
       +
               assert_eq!(response.flags.0, 0x8180);

     

       267
       267
       +
               assert_eq!(response.answers.len(), 2);

     

       268
       268
       +
       

     

       269
       269
       +
               // First answer

     

       270
       270
       +
               assert_eq!(response.answers[0].name, "example.com");

     

       271
       271
       +
               assert_eq!(response.answers[0].atype, QType::A);

     

       272
       272
       +
               assert_eq!(response.answers[0].aclass, QClass::IN);

     

       273
       273
       +
               assert_eq!(response.answers[0].ttl, 60);

     

       274
       274
       +
               if let Record::A(a) = &response.answers[0].record {

     

       275
       275
       +
                   assert_eq!(a.address, Ipv4Addr::new(93, 184, 216, 34));

     

       276
       276
       +
               } else {

     

       277
       277
       +
                   panic!("Expected A record");

     

       278
       278
       +
               }

     

       279
       279
       +
       

     

       280
       280
       +
               // Second answer

     

       281
       281
       +
               assert_eq!(response.answers[1].name, "example.com");

     

       282
       282
       +
               assert_eq!(response.answers[1].atype, QType::TXT);

     

       283
       283
       +
               assert_eq!(response.answers[1].aclass, QClass::IN);

     

       284
       284
       +
               assert_eq!(response.answers[1].ttl, 60);

     

       285
       285
       +
               if let Record::TXT(txt) = &response.answers[1].record

     

       286
       286
       +
                   && let Some(&text) = txt.text.first()

     

       287
       287
       +
               {

     

       288
       288
       +
                   assert_eq!(text, "test txt record");

     

       289
       289
       +
               } else {

     

       290
       290
       +
                   panic!("Expected TXT record");

     

       291
       291
       +
               }

     

       292
       292
       +
           }

     

       293
       293
       +
       

     

       294
       294
       +
           #[test]

     

       295
       295
       +
           fn parse_response_srv() {

     

       296
       296
       +
               let data = [

     

       297
       297
       +
                   //

     

       298
       298
       +
                   0xAA, 0xAA, // id

     

       299
       299
       +
                   0x81, 0x80, // flags

     

       300
       300
       +
                   0x00, 0x01, // one question

     

       301
       301
       +
                   0x00, 0x01, // one answer

     

       302
       302
       +
                   0x00, 0x00, // no authority

     

       303
       303
       +
                   0x00, 0x00, // no extra

     

       304
       304
       +
                   //

     

       305
       305
       +
                   0x04, 0x5f, 0x73, 0x69, 0x70, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x07, 0x65, 0x78, 0x61,

     

       306
       306
       +
                   0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, //

     

       307
       307
       +
                   //

     

       308
       308
       +
                   0x00, 0x21, // type SRV

     

       309
       309
       +
                   0x00, 0x01, // IN

     

       310
       310
       +
                   //

     

       311
       311
       +
                   0xc0, 0x0c, //

     

       312
       312
       +
                   //

     

       313
       313
       +
                   0x00, 0x21, // SRV

     

       314
       314
       +
                   0x00, 0x01, // IN

     

       315
       315
       +
                   0x00, 0x00, 0x00, 0x3C, // ttl 60

     

       316
       316
       +
                   //

     

       317
       317
       +
                   0x00, 0x19, // data len

     

       318
       318
       +
                   0x00, 0x0A, // prio

     

       319
       319
       +
                   0x00, 0x05, // weight

     

       320
       320
       +
                   0x13, 0xC4, // PORT

     

       321
       321
       +
                   //

     

       322
       322
       +
                   0x09, 0x73, 0x69, 0x70, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x07, 0x65, 0x78, 0x61,

     

       323
       323
       +
                   0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, //

     

       324
       324
       +
               ];

     

       325
       325
       +
       

     

       326
       326
       +
               let response = Response::parse(&mut data.as_slice(), data.as_slice()).unwrap();

     

       327
       327
       +
       

     

       328
       328
       +
               assert_eq!(response.id, 0xAAAA);

     

       329
       329
       +
               assert_eq!(response.flags.0, 0x8180);

     

       330
       330
       +
               assert_eq!(response.answers.len(), 1);

     

       331
       331
       +
       

     

       332
       332
       +
               // Answer

     

       333
       333
       +
               assert_eq!(response.answers[0].name, "_sip._tcp.example.com");

     

       334
       334
       +
               assert_eq!(response.answers[0].atype, QType::SRV);

     

       335
       335
       +
               assert_eq!(response.answers[0].aclass, QClass::IN);

     

       336
       336
       +
               assert_eq!(response.answers[0].ttl, 60);

     

       337
       337
       +
               let Record::SRV(srv) = &response.answers[0].record else {

     

       338
       338
       +
                   panic!("Expected SRV record");

     

       339
       339
       +
               };

     

       340
       340
       +
       

     

       341
       341
       +
               assert_eq!(srv.priority, 10);

     

       342
       342
       +
               assert_eq!(srv.weight, 5);

     

       343
       343
       +
               assert_eq!(srv.port, 5060);

     

       344
       344
       +
               assert_eq!(srv.target, "sipserver.example.com");

     

       345
       345
       +
           }

     

       346
       346
       +
       

     

       347
       347
       +
           #[test]

     

       348
       348
       +
           fn parse_response_back_forth() {

     

       349
       349
       +
               #[rustfmt::skip]

     

       350
       350
       +
               let data = [

     

       351
       351
       +
                   0, 0, // Transaction ID

     

       352
       352
       +
                   132, 0, // Response, Authoritative Answer, No Recursion

     

       353
       353
       +
                   0, 0, // 0 questions

     

       354
       354
       +
                   0, 4, // 4 answers

     

       355
       355
       +
                   0, 0, // 0 authority RRs

     

       356
       356
       +
                   0, 0, // 0 additional RRs

     

       357
       357
       +
                   // _midiriff

     

       358
       358
       +
                   9, 95, 109, 105, 100, 105, 114, 105, 102, 102, //

     

       359
       359
       +
                   // _udp

     

       360
       360
       +
                   4, 95, 117, 100, 112, //

     

       361
       361
       +
                   // local

     

       362
       362
       +
                   5, 108, 111, 99, 97, 108, //

     

       363
       363
       +
                   0,   // <end>

     

       364
       364
       +
                   //

     

       365
       365
       +
                   0, 12, // PTR

     

       366
       366
       +
                   0, 1, // Class IN

     

       367
       367
       +
                   0, 0, 0, 120, // TTL 120 seconds

     

       368
       368
       +
                   0, 10, // Data Length 10

     

       369
       369
       +
                   // pi35291

     

       370
       370
       +
                   7, 112, 105, 51, 53, 50, 57, 49, //

     

       371
       371
       +
                   //

     

       372
       372
       +
                   192, 12, // Pointer to _midirif._udp._local.

     

       373
       373
       +
                   //

     

       374
       374
       +
                   192, 44, // Pointer to instace name: pi35291._midirif._udp._local.

     

       375
       375
       +
                   0, 33, // SRV

     

       376
       376
       +
                   128, 1, // IN (Cache flush bit set)

     

       377
       377
       +
                   0, 0, 0, 120, // TTL 120 seconds

     

       378
       378
       +
                   0, 11, // Data Length 11

     

       379
       379
       +
                   0, 0, // Priority 0

     

       380
       380
       +
                   0, 0, // Weight 0

     

       381
       381
       +
                   137, 219, // Port 35291

     

       382
       382
       +
                   2, 112, 105, // _pi

     

       383
       383
       +
                   192, 27, // Pointer to: .local.

     

       384
       384
       +
                   // TXT (Empty)

     

       385
       385
       +
                   192, 44, 0, 16, 128, 1, 0, 0, 17, 148, 0, 1, 0,

     

       386
       386
       +
                   // A (10.1.1.9)

     

       387
       387
       +
                   192, 72, 0, 1, 128, 1, 0, 0, 0, 120, 0, 4, 10, 1, 1, 9,

     

       388
       388
       +
               ];

     

       389
       389
       +
       

     

       390
       390
       +
               let response = Response::parse(&mut data.as_slice(), data.as_slice()).unwrap();

     

       391
       391
       +
       

     

       392
       392
       +
               assert_eq!(response.answers[0].name, "_midiriff._udp.local");

     

       393
       393
       +
               assert_eq!(response.answers[0].ttl, 120);

     

       394
       394
       +
               let Record::PTR(ptr) = &response.answers[0].record else {

     

       395
       395
       +
                   panic!()

     

       396
       396
       +
               };

     

       397
       397
       +
               assert_eq!(ptr.name, "pi35291._midiriff._udp.local");

     

       398
       398
       +
       

     

       399
       399
       +
               let mut buffer = [0u8; 256];

     

       400
       400
       +
               let mut buffer = Encoder::new(&mut buffer);

     

       401
       401
       +
               response.serialize(&mut buffer).unwrap();

     

       402
       402
       +
       

     

       403
       403
       +
               let buffer = buffer.finish();

     

       404
       404
       +
       

     

       405
       405
       +
               let response2 = Response::parse(&mut &buffer[..], buffer).unwrap();

     

       406
       406
       +
       

     

       407
       407
       +
               assert_eq!(response, response2);

     

       408
       408
       +
           }

     

       409
       409
       +
       

     

       410
       410
       +
           #[test]

     

       411
       411
       +
           fn mdns_service_response() {

     

       412
       412
       +
               let mut response = Response {

     

       413
       413
       +
                   id: 0x1234,

     

       414
       414
       +
                   flags: Flags::standard_response(),

     

       415
       415
       +
                   queries: Vec::new(),

     

       416
       416
       +
                   answers: Vec::new(),

     

       417
       417
       +
               };

     

       418
       418
       +
       

     

       419
       419
       +
               let query = Query {

     

       420
       420
       +
                   name: Label::from("_test._udp.local"),

     

       421
       421
       +
                   qtype: QType::PTR,

     

       422
       422
       +
                   qclass: QClass::IN,

     

       423
       423
       +
               };

     

       424
       424
       +
               response.queries.push(query);

     

       425
       425
       +
       

     

       426
       426
       +
               let ptr_answer = Answer {

     

       427
       427
       +
                   name: Label::from("_test._udp.local"),

     

       428
       428
       +
                   atype: QType::PTR,

     

       429
       429
       +
                   aclass: QClass::IN,

     

       430
       430
       +
                   ttl: 4500,

     

       431
       431
       +
                   record: Record::PTR(PTR {

     

       432
       432
       +
                       name: Label::from("test-service._test._udp.local"),

     

       433
       433
       +
                   }),

     

       434
       434
       +
               };

     

       435
       435
       +
               response.answers.push(ptr_answer);

     

       436
       436
       +
       

     

       437
       437
       +
               let srv_answer = Answer {

     

       438
       438
       +
                   name: Label::from("test-service._test._udp.local"),

     

       439
       439
       +
                   atype: QType::SRV,

     

       440
       440
       +
                   aclass: QClass::IN,

     

       441
       441
       +
                   ttl: 120,

     

       442
       442
       +
                   record: Record::SRV(SRV {

     

       443
       443
       +
                       priority: 0,

     

       444
       444
       +
                       weight: 0,

     

       445
       445
       +
                       port: 8080,

     

       446
       446
       +
                       target: Label::from("host.local"),

     

       447
       447
       +
                   }),

     

       448
       448
       +
               };

     

       449
       449
       +
               response.answers.push(srv_answer);

     

       450
       450
       +
       

     

       451
       451
       +
               let txt_answer = Answer {

     

       452
       452
       +
                   name: Label::from("test-service._test._udp.local"),

     

       453
       453
       +
                   atype: QType::TXT,

     

       454
       454
       +
                   aclass: QClass::IN,

     

       455
       455
       +
                   ttl: 120,

     

       456
       456
       +
                   record: Record::TXT(TXT {

     

       457
       457
       +
                       text: vec!["path=/test"],

     

       458
       458
       +
                   }),

     

       459
       459
       +
               };

     

       460
       460
       +
               response.answers.push(txt_answer);

     

       461
       461
       +
       

     

       462
       462
       +
               let a_answer = Answer {

     

       463
       463
       +
                   name: Label::from("host.local"),

     

       464
       464
       +
                   atype: QType::A,

     

       465
       465
       +
                   aclass: QClass::IN,

     

       466
       466
       +
                   ttl: 120,

     

       467
       467
       +
                   record: Record::A(A {

     

       468
       468
       +
                       address: Ipv4Addr::new(192, 168, 1, 100),

     

       469
       469
       +
                   }),

     

       470
       470
       +
               };

     

       471
       471
       +
               response.answers.push(a_answer);

     

       472
       472
       +
       

     

       473
       473
       +
               let mut buffer = [0u8; 256];

     

       474
       474
       +
               let mut buffer = Encoder::new(&mut buffer);

     

       475
       475
       +
               response.serialize(&mut buffer).unwrap();

     

       476
       476
       +
       

     

       477
       477
       +
               let buffer = buffer.finish();

     

       478
       478
       +
       

     

       479
       479
       +
               let parsed_response = Response::parse(&mut &buffer[..], buffer).unwrap();

     

       480
       480
       +
       

     

       481
       481
       +
               assert_eq!(response, parsed_response);

     

       482
       482
       +
           }

     

       483
       483
       +
       }

+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
       +
       }

+103

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 =

     

       78
       78
       +
                           req.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())

     

       85
       85
       +
                                       .then_some((q.qtype, q.qclass)),

     

       86
       86
       +
                                   QType::Any | QType::Unknown(_) => None,

     

       87
       87
       +
                               })

     

       88
       88
       +
                               .collect::<Vec<_>>();

     

       89
       89
       +
       

     

       90
       90
       +
                       if !valid_queries.is_empty() {

     

       91
       91
       +
                           self.broadcast(

     

       92
       92
       +
                               ResponseKind::QueryResponse(valid_queries),

     

       93
       93
       +
                               req.flags,

     

       94
       94
       +
                               req.id,

     

       95
       95
       +
                               req.queries,

     

       96
       96
       +
                               outgoing,

     

       97
       97
       +
                           )

     

       98
       98
       +
                       } else {

     

       99
       99
       +
                           None

     

       100
       100
       +
                       }

     

       101
       101
       +
                   })

     

       102
       102
       +
           }

     

       103
       103
       +
       }

+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
       +
       }