bt_rfcomm/frame/mux_commands/
remote_line_status.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use bitfield::bitfield;
6use packet_encoding::{decodable_enum, Decodable, Encodable};
7
8use crate::frame::FrameParseError;
9use crate::DLCI;
10
11/// The length (in bytes) of the RLS command.
12/// Defined in GSM 7.10 Section 5.4.6.3.10.
13const REMOTE_LINE_STATUS_COMMAND_LENGTH: usize = 2;
14
15bitfield! {
16    struct RlsAddressField(u8);
17    impl Debug;
18    pub bool, ea_bit, set_ea_bit: 0;
19    pub bool, cr_bit, set_cr_bit: 1;
20    pub u8, dlci_raw, set_dlci: 7, 2;
21}
22
23impl RlsAddressField {
24    fn dlci(&self) -> Result<DLCI, FrameParseError> {
25        DLCI::try_from(self.dlci_raw())
26    }
27}
28
29decodable_enum! {
30    /// The error types supported in the Remote Line Status command.
31    /// See GSM 07.10 Section 5.4.6.3.10 for the defined variants.
32    pub enum RlsError<u8, FrameParseError, OutOfRange> {
33        /// Received character overwrote an unread character.
34        Overrun = 0b001,
35        /// Received character's parity was incorrect.
36        Parity = 0b010,
37        /// Received character did not terminate with a stop bit.
38        Framing = 0b100,
39    }
40}
41
42bitfield! {
43    pub struct RlsErrorField(u8);
44    impl Debug;
45    pub bool, error_occurred, set_error_occurred: 0;
46    pub u8, error, set_error: 3,1;
47}
48
49impl RlsErrorField {
50    fn from_error(error: RlsError) -> Self {
51        let mut field = Self(0);
52        field.set_error_occurred(true);
53        field.set_error(u8::from(&error));
54        field
55    }
56
57    const fn no_error() -> Self {
58        Self(0)
59    }
60}
61
62impl PartialEq for RlsErrorField {
63    fn eq(&self, other: &Self) -> bool {
64        self.0 == other.0
65    }
66}
67
68impl Clone for RlsErrorField {
69    fn clone(&self) -> Self {
70        Self(self.0)
71    }
72}
73
74/// The Remote Line Status Command is used to indicate the status of the Remote Port Line.
75/// It is used whenever the port settings change.
76/// Defined in GSM 7.10 Section 5.4.6.3.10, with RFCOMM specifics in RFCOMM 5.5.2.
77#[derive(Clone, Debug, PartialEq)]
78pub struct RemoteLineStatusParams {
79    pub dlci: DLCI,
80    /// The status associated with the remote port line.
81    pub status: RlsErrorField,
82}
83
84impl RemoteLineStatusParams {
85    pub fn new(dlci: DLCI, status: Option<RlsError>) -> Self {
86        let status = if let Some(e) = status {
87            RlsErrorField::from_error(e)
88        } else {
89            RlsErrorField::no_error()
90        };
91        Self { dlci, status }
92    }
93}
94
95impl Decodable for RemoteLineStatusParams {
96    type Error = FrameParseError;
97
98    fn decode(buf: &[u8]) -> Result<Self, FrameParseError> {
99        if buf.len() != REMOTE_LINE_STATUS_COMMAND_LENGTH {
100            return Err(FrameParseError::InvalidBufferLength(
101                REMOTE_LINE_STATUS_COMMAND_LENGTH,
102                buf.len(),
103            ));
104        }
105
106        // Address field.
107        let address_field = RlsAddressField(buf[0]);
108        let dlci = address_field.dlci()?;
109
110        // Status field.
111        let status = RlsErrorField(buf[1]);
112
113        Ok(RemoteLineStatusParams { dlci, status })
114    }
115}
116
117impl Encodable for RemoteLineStatusParams {
118    type Error = FrameParseError;
119
120    fn encoded_len(&self) -> usize {
121        REMOTE_LINE_STATUS_COMMAND_LENGTH
122    }
123
124    fn encode(&self, buf: &mut [u8]) -> Result<(), FrameParseError> {
125        if buf.len() < self.encoded_len() {
126            return Err(FrameParseError::BufferTooSmall);
127        }
128
129        // E/A bit = 1, C/R bit = 1 (always). See GSM 7.10 Section 5.4.6.3.10 Table 14.
130        let mut address_field = RlsAddressField(0);
131        address_field.set_ea_bit(true);
132        address_field.set_cr_bit(true);
133        address_field.set_dlci(u8::from(self.dlci));
134        buf[0] = address_field.0;
135        buf[1] = self.status.0;
136
137        Ok(())
138    }
139}
140
141#[cfg(test)]
142mod tests {
143    use super::*;
144
145    use assert_matches::assert_matches;
146
147    #[test]
148    fn test_decode_rls_invalid_buf() {
149        let buf = [0x00, 0x01, 0x02]; // Length = 3, invalid.
150        assert_matches!(
151            RemoteLineStatusParams::decode(&buf[..]),
152            Err(FrameParseError::InvalidBufferLength(REMOTE_LINE_STATUS_COMMAND_LENGTH, 3))
153        );
154    }
155
156    #[test]
157    fn test_decode_rls_invalid_dlci() {
158        let buf = [
159            0b00000111, // DLCI = 1 is invalid, E/A = 1, Bit2 = 1 always.
160            0b00000000, // Bit1 = 0 -> No status.
161        ];
162        assert_matches!(
163            RemoteLineStatusParams::decode(&buf[..]),
164            Err(FrameParseError::InvalidDLCI(1))
165        );
166    }
167
168    #[test]
169    fn test_decode_rls_no_status() {
170        let buf = [
171            0b00001011, // DLCI = 2, E/A = 1, Bit2 = 1 always.
172            0b00000000, // Bit1 = 0 -> No status.
173        ];
174        let expected =
175            RemoteLineStatusParams { dlci: DLCI::try_from(2).unwrap(), status: RlsErrorField(0) };
176        let res = RemoteLineStatusParams::decode(&buf[..]).unwrap();
177        assert_eq!(res, expected);
178        assert_eq!(res.status.error_occurred(), false);
179    }
180
181    #[test]
182    fn test_decode_rls_with_status() {
183        let buf = [
184            0b00001011, // DLCI = 2, E/A = 1, Bit2 = 1 always.
185            0b00000101, // Bit1 = 1 -> Status. Status = 010 (Parity Error).
186        ];
187        let expected =
188            RemoteLineStatusParams { dlci: DLCI::try_from(2).unwrap(), status: RlsErrorField(5) };
189        let res = RemoteLineStatusParams::decode(&buf[..]).unwrap();
190        assert_eq!(res, expected);
191        assert_eq!(res.status.error_occurred(), true);
192        assert_eq!(res.status.error(), 0b010);
193    }
194
195    #[test]
196    fn test_encode_rls_invalid_buf() {
197        let command = RemoteLineStatusParams::new(DLCI::try_from(7).unwrap(), None);
198        let mut buf = [0x01]; // Too small.
199        assert_matches!(command.encode(&mut buf), Err(FrameParseError::BufferTooSmall));
200    }
201
202    #[test]
203    fn test_encode_rls_with_no_status() {
204        let command = RemoteLineStatusParams::new(DLCI::try_from(7).unwrap(), None);
205        let mut buf = vec![0; command.encoded_len()];
206        assert!(command.encode(&mut buf).is_ok());
207        let expected = [
208            0b00011111, // DLCI = 7, E/A = 1, Bit2 = 1 always.
209            0b00000000, // Bit1 = 0 -> No error status.
210        ];
211        assert_eq!(buf, expected);
212    }
213
214    #[test]
215    fn test_encode_rls_with_error_status() {
216        let errors = vec![RlsError::Overrun, RlsError::Parity, RlsError::Framing];
217        // Bit1 = 1 indicates error status. Bits 2-4 specify the error. Bits 5-8 are reserved.
218        let expected_error_bits = vec![0b00000011, 0b00000101, 0b00001001];
219
220        for (error_status, expected_bits) in errors.into_iter().zip(expected_error_bits.into_iter())
221        {
222            let command =
223                RemoteLineStatusParams::new(DLCI::try_from(7).unwrap(), Some(error_status));
224            let mut buf = vec![0; command.encoded_len()];
225            assert!(command.encode(&mut buf).is_ok());
226
227            let mut expected = vec![
228                0b00011111, // DLCI = 7, Bit2 = 1 always, E/A = 1.
229            ];
230            expected.push(expected_bits);
231            assert_eq!(buf, expected);
232        }
233    }
234}
bt_rfcomm/frame/mux_commands/remote_line_status.rs

bt_rfcomm/frame/mux_commands/
remote_line_status.rs
