1 //
2 // Copyright 20 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include "hci/h4_parser.h"  // for H4Parser, PacketType, H4Pars...
18 
19 #include <array>
20 #include <cstddef>     // for size_t
21 #include <cstdint>     // for uint8_t, int32_t
22 #include <functional>  // for function
23 #include <utility>     // for move
24 #include <vector>      // for vector
25 
26 #include "log.h"  // for LOG_ALWAYS_FATAL, LOG_INFO
27 
28 namespace rootcanal {
29 
Reset()30 void H4Parser::Reset() {
31   state_ = HCI_TYPE;
32   packet_.clear();
33   bytes_wanted_ = 0;
34   packet_type_ = 0;
35 }
36 
HciGetPacketLengthForType(PacketType type,const uint8_t * preamble)37 size_t H4Parser::HciGetPacketLengthForType(PacketType type,
38                                            const uint8_t* preamble) {
39   static const size_t
40       packet_length_offset[static_cast<size_t>(PacketType::ISO) + 1] = {
41           0,
42           H4Parser::COMMAND_LENGTH_OFFSET,
43           H4Parser::ACL_LENGTH_OFFSET,
44           H4Parser::SCO_LENGTH_OFFSET,
45           H4Parser::EVENT_LENGTH_OFFSET,
46           H4Parser::ISO_LENGTH_OFFSET,
47       };
48 
49   size_t offset = packet_length_offset[static_cast<size_t>(type)];
50   size_t size = preamble[offset];
51   if (type == PacketType::ACL) {
52     size |= ((size_t)preamble[offset + 1]) << 8;
53   }
54   if (type == PacketType::ISO) {
55     size |= ((size_t)preamble[offset + 1] & 0x0fU) << 8;
56   }
57   return size;
58 }
59 
H4Parser(PacketReadCallback command_cb,PacketReadCallback event_cb,PacketReadCallback acl_cb,PacketReadCallback sco_cb,PacketReadCallback iso_cb,bool enable_recovery_state)60 H4Parser::H4Parser(PacketReadCallback command_cb, PacketReadCallback event_cb,
61                    PacketReadCallback acl_cb, PacketReadCallback sco_cb,
62                    PacketReadCallback iso_cb, bool enable_recovery_state)
63     : command_cb_(std::move(command_cb)),
64       event_cb_(std::move(event_cb)),
65       acl_cb_(std::move(acl_cb)),
66       sco_cb_(std::move(sco_cb)),
67       iso_cb_(std::move(iso_cb)),
68       enable_recovery_state_(enable_recovery_state) {}
69 
OnPacketReady()70 void H4Parser::OnPacketReady() {
71   switch (hci_packet_type_) {
72     case PacketType::COMMAND:
73       command_cb_(packet_);
74       break;
75     case PacketType::ACL:
76       acl_cb_(packet_);
77       break;
78     case PacketType::SCO:
79       sco_cb_(packet_);
80       break;
81     case PacketType::EVENT:
82       event_cb_(packet_);
83       break;
84     case PacketType::ISO:
85       iso_cb_(packet_);
86       break;
87     default:
88       LOG_ALWAYS_FATAL("Unimplemented packet type %d",
89                        static_cast<int>(hci_packet_type_));
90   }
91   // Get ready for the next type byte.
92   hci_packet_type_ = PacketType::UNKNOWN;
93 }
94 
BytesRequested()95 size_t H4Parser::BytesRequested() {
96   switch (state_) {
97     case HCI_TYPE:
98     case HCI_RECOVERY:
99       return 1;
100     case HCI_PREAMBLE:
101     case HCI_PAYLOAD:
102       return bytes_wanted_;
103   }
104 }
105 
Consume(const uint8_t * buffer,int32_t bytes_read)106 bool H4Parser::Consume(const uint8_t* buffer, int32_t bytes_read) {
107   size_t bytes_to_read = BytesRequested();
108   if (bytes_read <= 0) {
109     LOG_INFO("remote disconnected, or unhandled error?");
110     return false;
111   }
112   if ((uint32_t)bytes_read > BytesRequested()) {
113     LOG_ALWAYS_FATAL("More bytes read (%u) than expected (%u)!",
114                      static_cast<int>(bytes_read),
115                      static_cast<int>(bytes_to_read));
116   }
117 
118   static const size_t preamble_size[static_cast<size_t>(PacketType::ISO) + 1] =
119       {
120           0,
121           H4Parser::COMMAND_PREAMBLE_SIZE,
122           H4Parser::ACL_PREAMBLE_SIZE,
123           H4Parser::SCO_PREAMBLE_SIZE,
124           H4Parser::EVENT_PREAMBLE_SIZE,
125           H4Parser::ISO_PREAMBLE_SIZE,
126       };
127   switch (state_) {
128     case HCI_TYPE:
129       // bytes_read >= 1
130       packet_type_ = *buffer;
131       packet_.clear();
132       break;
133 
134     case HCI_RECOVERY: {
135       // Skip all received bytes until the HCI Reset command is received.
136       // The parser can end up in a bad state when the host is restarted.
137       const std::array<uint8_t, 4> reset_command{0x01, 0x03, 0x0c, 0x00};
138       size_t offset = packet_.size();
139       LOG_WARN("Received byte in recovery state : 0x%x",
140                static_cast<unsigned>(*buffer));
141       packet_.push_back(*buffer);
142 
143       // Last byte does not match expected byte in the sequence.
144       // Drop all the bytes and start over.
145       if (packet_[offset] != reset_command[offset]) {
146         packet_.clear();
147         // The mismatched byte can also be the first of the correct sequence.
148         if (*buffer == reset_command[0]) {
149           packet_.push_back(*buffer);
150         }
151       }
152 
153       // Received full reset command.
154       if (packet_.size() == reset_command.size()) {
155         LOG_INFO("Received HCI Reset command, exiting recovery state");
156         // Pop the Idc from the received packet.
157         packet_.erase(packet_.begin());
158         bytes_wanted_ = 0;
159       }
160       break;
161     }
162 
163     case HCI_PREAMBLE:
164     case HCI_PAYLOAD:
165       packet_.insert(packet_.end(), buffer, buffer + bytes_read);
166       bytes_wanted_ -= bytes_read;
167       break;
168   }
169 
170   switch (state_) {
171     case HCI_TYPE:
172       hci_packet_type_ = static_cast<PacketType>(packet_type_);
173       if (hci_packet_type_ != PacketType::ACL &&
174           hci_packet_type_ != PacketType::SCO &&
175           hci_packet_type_ != PacketType::COMMAND &&
176           hci_packet_type_ != PacketType::EVENT &&
177           hci_packet_type_ != PacketType::ISO) {
178         if (!enable_recovery_state_) {
179           LOG_ALWAYS_FATAL("Received invalid packet type 0x%x",
180                            static_cast<unsigned>(packet_type_));
181         }
182         LOG_ERROR("Received invalid packet type 0x%x, entering recovery state",
183                   static_cast<unsigned>(packet_type_));
184         state_ = HCI_RECOVERY;
185         hci_packet_type_ = PacketType::COMMAND;
186         bytes_wanted_ = 1;
187       } else {
188         state_ = HCI_PREAMBLE;
189         bytes_wanted_ = preamble_size[static_cast<size_t>(hci_packet_type_)];
190       }
191       break;
192     case HCI_PREAMBLE:
193       if (bytes_wanted_ == 0) {
194         size_t payload_size =
195             HciGetPacketLengthForType(hci_packet_type_, packet_.data());
196         if (payload_size == 0) {
197           OnPacketReady();
198           state_ = HCI_TYPE;
199         } else {
200           bytes_wanted_ = payload_size;
201           state_ = HCI_PAYLOAD;
202         }
203       }
204       break;
205     case HCI_RECOVERY:
206     case HCI_PAYLOAD:
207       if (bytes_wanted_ == 0) {
208         OnPacketReady();
209         state_ = HCI_TYPE;
210       }
211       break;
212   }
213   return true;
214 }
215 }  // namespace rootcanal
216