1//
2// Copyright 2015 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#define LOG_TAG "dual_mode_controller"
18
19#include "dual_mode_controller.h"
20
21#include <memory>
22
23#include <base/logging.h>
24#include "base/files/file_util.h"
25#include "base/json/json_reader.h"
26#include "base/values.h"
27#include "event_packet.h"
28
29#include "osi/include/log.h"
30#include "osi/include/osi.h"
31#include "stack/include/hcidefs.h"
32
33using std::vector;
34
35namespace {
36
37// Included in certain events to indicate success (specific to the event
38// context).
39const uint8_t kSuccessStatus = 0;
40
41const uint8_t kUnknownHciCommand = 1;
42
43// The location of the config file loaded to populate controller attributes.
44const std::string kControllerPropertiesFile =
45    "/etc/bluetooth/controller_properties.json";
46
47// Inquiry modes for specifiying inquiry result formats.
48const uint8_t kStandardInquiry = 0x00;
49const uint8_t kRssiInquiry = 0x01;
50const uint8_t kExtendedOrRssiInquiry = 0x02;
51
52// The bd address of another (fake) device.
53const vector<uint8_t> kOtherDeviceBdAddress = {6, 5, 4, 3, 2, 1};
54
55void LogCommand(const char* command) {
56  LOG_INFO(LOG_TAG, "Controller performing command: %s", command);
57}
58
59// Functions used by JSONValueConverter to read stringified JSON into Properties
60// object.
61bool ParseUint8t(const base::StringPiece& value, uint8_t* field) {
62  *field = std::stoi(value.as_string());
63  return true;
64}
65
66bool ParseUint16t(const base::StringPiece& value, uint16_t* field) {
67  *field = std::stoi(value.as_string());
68  return true;
69}
70
71}  // namespace
72
73namespace test_vendor_lib {
74
75void DualModeController::AddControllerEvent(std::chrono::milliseconds delay,
76                                            const TaskCallback& task) {
77  controller_events_.push_back(schedule_task_(delay, task));
78}
79
80void DualModeController::SendCommandCompleteSuccess(
81    uint16_t command_opcode) const {
82  send_event_(EventPacket::CreateCommandCompleteOnlyStatusEvent(
83      command_opcode, kSuccessStatus));
84}
85
86void DualModeController::SendCommandCompleteOnlyStatus(uint16_t command_opcode,
87                                                       uint8_t status) const {
88  send_event_(EventPacket::CreateCommandCompleteOnlyStatusEvent(command_opcode,
89                                                                status));
90}
91
92void DualModeController::SendCommandStatus(uint8_t status,
93                                           uint16_t command_opcode) const {
94  send_event_(EventPacket::CreateCommandStatusEvent(status, command_opcode));
95}
96
97void DualModeController::SendCommandStatusSuccess(
98    uint16_t command_opcode) const {
99  SendCommandStatus(kSuccessStatus, command_opcode);
100}
101
102DualModeController::DualModeController()
103    : state_(kStandby),
104      properties_(kControllerPropertiesFile),
105      test_channel_state_(kNone) {
106#define SET_HANDLER(opcode, method)                                     \
107  active_hci_commands_[opcode] = [this](const vector<uint8_t>& param) { \
108    method(param);                                                      \
109  };
110  SET_HANDLER(HCI_RESET, HciReset);
111  SET_HANDLER(HCI_READ_BUFFER_SIZE, HciReadBufferSize);
112  SET_HANDLER(HCI_HOST_BUFFER_SIZE, HciHostBufferSize);
113  SET_HANDLER(HCI_READ_LOCAL_VERSION_INFO, HciReadLocalVersionInformation);
114  SET_HANDLER(HCI_READ_BD_ADDR, HciReadBdAddr);
115  SET_HANDLER(HCI_READ_LOCAL_SUPPORTED_CMDS, HciReadLocalSupportedCommands);
116  SET_HANDLER(HCI_READ_LOCAL_SUPPORTED_CODECS, HciReadLocalSupportedCodecs);
117  SET_HANDLER(HCI_READ_LOCAL_EXT_FEATURES, HciReadLocalExtendedFeatures);
118  SET_HANDLER(HCI_WRITE_SIMPLE_PAIRING_MODE, HciWriteSimplePairingMode);
119  SET_HANDLER(HCI_WRITE_LE_HOST_SUPPORT, HciWriteLeHostSupport);
120  SET_HANDLER(HCI_SET_EVENT_MASK, HciSetEventMask);
121  SET_HANDLER(HCI_WRITE_INQUIRY_MODE, HciWriteInquiryMode);
122  SET_HANDLER(HCI_WRITE_PAGESCAN_TYPE, HciWritePageScanType);
123  SET_HANDLER(HCI_WRITE_INQSCAN_TYPE, HciWriteInquiryScanType);
124  SET_HANDLER(HCI_WRITE_CLASS_OF_DEVICE, HciWriteClassOfDevice);
125  SET_HANDLER(HCI_WRITE_PAGE_TOUT, HciWritePageTimeout);
126  SET_HANDLER(HCI_WRITE_DEF_POLICY_SETTINGS, HciWriteDefaultLinkPolicySettings);
127  SET_HANDLER(HCI_READ_LOCAL_NAME, HciReadLocalName);
128  SET_HANDLER(HCI_CHANGE_LOCAL_NAME, HciWriteLocalName);
129  SET_HANDLER(HCI_WRITE_EXT_INQ_RESPONSE, HciWriteExtendedInquiryResponse);
130  SET_HANDLER(HCI_WRITE_VOICE_SETTINGS, HciWriteVoiceSetting);
131  SET_HANDLER(HCI_WRITE_CURRENT_IAC_LAP, HciWriteCurrentIacLap);
132  SET_HANDLER(HCI_WRITE_INQUIRYSCAN_CFG, HciWriteInquiryScanActivity);
133  SET_HANDLER(HCI_WRITE_SCAN_ENABLE, HciWriteScanEnable);
134  SET_HANDLER(HCI_SET_EVENT_FILTER, HciSetEventFilter);
135  SET_HANDLER(HCI_INQUIRY, HciInquiry);
136  SET_HANDLER(HCI_INQUIRY_CANCEL, HciInquiryCancel);
137  SET_HANDLER(HCI_DELETE_STORED_LINK_KEY, HciDeleteStoredLinkKey);
138  SET_HANDLER(HCI_RMT_NAME_REQUEST, HciRemoteNameRequest);
139  SET_HANDLER(HCI_BLE_SET_EVENT_MASK, HciLeSetEventMask);
140  SET_HANDLER(HCI_BLE_READ_BUFFER_SIZE, HciLeReadBufferSize);
141  SET_HANDLER(HCI_BLE_READ_LOCAL_SPT_FEAT, HciLeReadLocalSupportedFeatures);
142  SET_HANDLER(HCI_BLE_WRITE_RANDOM_ADDR, HciLeSetRandomAddress);
143  SET_HANDLER(HCI_BLE_WRITE_ADV_DATA, HciLeSetAdvertisingData);
144  SET_HANDLER(HCI_BLE_WRITE_ADV_PARAMS, HciLeSetAdvertisingParameters);
145  SET_HANDLER(HCI_BLE_WRITE_SCAN_PARAMS, HciLeSetScanParameters);
146  SET_HANDLER(HCI_BLE_WRITE_SCAN_ENABLE, HciLeSetScanEnable);
147  SET_HANDLER(HCI_BLE_READ_WHITE_LIST_SIZE, HciLeReadWhiteListSize);
148  SET_HANDLER(HCI_BLE_RAND, HciLeRand);
149  SET_HANDLER(HCI_BLE_READ_SUPPORTED_STATES, HciLeReadSupportedStates);
150  SET_HANDLER((HCI_GRP_VENDOR_SPECIFIC | 0x27), HciBleVendorSleepMode);
151  SET_HANDLER(HCI_BLE_VENDOR_CAP_OCF, HciBleVendorCap);
152  SET_HANDLER(HCI_BLE_MULTI_ADV_OCF, HciBleVendorMultiAdv);
153  SET_HANDLER((HCI_GRP_VENDOR_SPECIFIC | 0x155), HciBleVendor155);
154  SET_HANDLER((HCI_GRP_VENDOR_SPECIFIC | 0x157), HciBleVendor157);
155  SET_HANDLER(HCI_BLE_ENERGY_INFO_OCF, HciBleEnergyInfo);
156  SET_HANDLER(HCI_BLE_EXTENDED_SCAN_PARAMS_OCF, HciBleExtendedScanParams);
157#undef SET_HANDLER
158
159#define SET_TEST_HANDLER(command_name, method)  \
160  active_test_channel_commands_[command_name] = \
161      [this](const vector<std::string>& param) { method(param); };
162  SET_TEST_HANDLER("CLEAR", TestChannelClear);
163  SET_TEST_HANDLER("CLEAR_EVENT_DELAY", TestChannelClearEventDelay);
164  SET_TEST_HANDLER("DISCOVER", TestChannelDiscover);
165  SET_TEST_HANDLER("SET_EVENT_DELAY", TestChannelSetEventDelay);
166  SET_TEST_HANDLER("TIMEOUT_ALL", TestChannelTimeoutAll);
167#undef SET_TEST_HANDLER
168}
169
170void DualModeController::RegisterTaskScheduler(
171    std::function<AsyncTaskId(std::chrono::milliseconds, const TaskCallback&)>
172        oneshotScheduler) {
173  schedule_task_ = oneshotScheduler;
174}
175
176void DualModeController::RegisterPeriodicTaskScheduler(
177    std::function<AsyncTaskId(std::chrono::milliseconds,
178                              std::chrono::milliseconds, const TaskCallback&)>
179        periodicScheduler) {
180  schedule_periodic_task_ = periodicScheduler;
181}
182
183void DualModeController::RegisterTaskCancel(
184    std::function<void(AsyncTaskId)> task_cancel) {
185  cancel_task_ = task_cancel;
186}
187
188void DualModeController::HandleTestChannelCommand(
189    const std::string& name, const vector<std::string>& args) {
190  if (active_test_channel_commands_.count(name) == 0) return;
191  active_test_channel_commands_[name](args);
192}
193
194void DualModeController::HandleCommand(
195    std::unique_ptr<CommandPacket> command_packet) {
196  uint16_t opcode = command_packet->GetOpcode();
197  LOG_INFO(LOG_TAG, "Command opcode: 0x%04X, OGF: 0x%04X, OCF: 0x%04X", opcode,
198           command_packet->GetOGF(), command_packet->GetOCF());
199
200  // The command hasn't been registered with the handler yet. There is nothing
201  // to do.
202  if (active_hci_commands_.count(opcode) == 0)
203    return;
204  else if (test_channel_state_ == kTimeoutAll)
205    return;
206  active_hci_commands_[opcode](command_packet->GetPayload());
207}
208
209void DualModeController::RegisterEventChannel(
210    const std::function<void(std::unique_ptr<EventPacket>)>& callback) {
211  send_event_ = callback;
212}
213
214void DualModeController::HandleTimerTick() {
215  // PageScan();
216  if (le_scan_enable_) LOG_ERROR(LOG_TAG, "LE scan");
217  // LeScan();
218}
219
220void DualModeController::SetTimerPeriod(std::chrono::milliseconds new_period) {
221  timer_period_ = new_period;
222
223  if (timer_tick_task_ == kInvalidTaskId) return;
224
225  // Restart the timer with the new period
226  StopTimer();
227  StartTimer();
228}
229
230void DualModeController::StartTimer() {
231  LOG_ERROR(LOG_TAG, "StartTimer");
232  timer_tick_task_ = schedule_periodic_task_(
233      std::chrono::milliseconds(0), timer_period_,
234      [this]() { DualModeController::HandleTimerTick(); });
235}
236
237void DualModeController::StopTimer() {
238  LOG_ERROR(LOG_TAG, "StopTimer");
239  cancel_task_(timer_tick_task_);
240  timer_tick_task_ = kInvalidTaskId;
241}
242
243void DualModeController::TestChannelClear(
244    UNUSED_ATTR const vector<std::string>& args) {
245  LogCommand("TestChannel Clear");
246  test_channel_state_ = kNone;
247}
248
249void DualModeController::TestChannelDiscover(
250    UNUSED_ATTR const vector<std::string>& args) {
251  LogCommand("TestChannel Discover");
252  /* TODO: Replace with adding devices */
253  /*
254
255    for (size_t i = 0; i < args.size() - 1; i += 2)
256      SendExtendedInquiryResult(args[i], args[i + 1]);
257  */
258}
259
260void DualModeController::TestChannelTimeoutAll(
261    UNUSED_ATTR const vector<std::string>& args) {
262  LogCommand("TestChannel Timeout All");
263  test_channel_state_ = kTimeoutAll;
264}
265
266void DualModeController::TestChannelSetEventDelay(
267    const vector<std::string>& args UNUSED_ATTR) {
268  LogCommand("TestChannel Set Event Delay");
269  test_channel_state_ = kDelayedResponse;
270}
271
272void DualModeController::TestChannelClearEventDelay(
273    UNUSED_ATTR const vector<std::string>& args) {
274  LogCommand("TestChannel Clear Event Delay");
275  test_channel_state_ = kNone;
276}
277
278void DualModeController::HciReset(UNUSED_ATTR const vector<uint8_t>& args) {
279  LogCommand("Reset");
280  state_ = kStandby;
281  if (timer_tick_task_ != kInvalidTaskId) {
282    LOG_INFO(LOG_TAG, "The timer was already running!");
283    StopTimer();
284  }
285  LOG_INFO(LOG_TAG, "Starting timer.");
286  StartTimer();
287
288  SendCommandCompleteSuccess(HCI_RESET);
289}
290
291void DualModeController::HciReadBufferSize(
292    UNUSED_ATTR const vector<uint8_t>& args) {
293  LogCommand("Read Buffer Size");
294  std::unique_ptr<EventPacket> command_complete =
295      EventPacket::CreateCommandCompleteReadBufferSize(
296          kSuccessStatus, properties_.GetAclDataPacketSize(),
297          properties_.GetSynchronousDataPacketSize(),
298          properties_.GetTotalNumAclDataPackets(),
299          properties_.GetTotalNumSynchronousDataPackets());
300
301  send_event_(std::move(command_complete));
302}
303
304void DualModeController::HciHostBufferSize(
305    UNUSED_ATTR const vector<uint8_t>& args) {
306  LogCommand("Host Buffer Size");
307  SendCommandCompleteSuccess(HCI_HOST_BUFFER_SIZE);
308}
309
310void DualModeController::HciReadLocalVersionInformation(
311    UNUSED_ATTR const vector<uint8_t>& args) {
312  LogCommand("Read Local Version Information");
313  std::unique_ptr<EventPacket> command_complete =
314      EventPacket::CreateCommandCompleteReadLocalVersionInformation(
315          kSuccessStatus, properties_.GetVersion(), properties_.GetRevision(),
316          properties_.GetLmpPalVersion(), properties_.GetManufacturerName(),
317          properties_.GetLmpPalSubversion());
318  send_event_(std::move(command_complete));
319}
320
321void DualModeController::HciReadBdAddr(
322    UNUSED_ATTR const vector<uint8_t>& args) {
323  std::unique_ptr<EventPacket> command_complete =
324      EventPacket::CreateCommandCompleteReadBdAddr(kSuccessStatus,
325                                                   properties_.GetAddress());
326  send_event_(std::move(command_complete));
327}
328
329void DualModeController::HciReadLocalSupportedCommands(
330    UNUSED_ATTR const vector<uint8_t>& args) {
331  LogCommand("Read Local Supported Commands");
332  std::unique_ptr<EventPacket> command_complete =
333      EventPacket::CreateCommandCompleteReadLocalSupportedCommands(
334          kSuccessStatus, properties_.GetLocalSupportedCommands());
335  send_event_(std::move(command_complete));
336}
337
338void DualModeController::HciReadLocalSupportedCodecs(
339    UNUSED_ATTR const vector<uint8_t>& args) {
340  LogCommand("Read Local Supported Codecs");
341  std::unique_ptr<EventPacket> command_complete =
342      EventPacket::CreateCommandCompleteReadLocalSupportedCodecs(
343          kSuccessStatus, properties_.GetSupportedCodecs(),
344          properties_.GetVendorSpecificCodecs());
345  send_event_(std::move(command_complete));
346}
347
348void DualModeController::HciReadLocalExtendedFeatures(
349    const vector<uint8_t>& args) {
350  LogCommand("Read Local Extended Features");
351  CHECK(args.size() == 2);
352  std::unique_ptr<EventPacket> command_complete =
353      EventPacket::CreateCommandCompleteReadLocalExtendedFeatures(
354          kSuccessStatus, args[1],
355          properties_.GetLocalExtendedFeaturesMaximumPageNumber(),
356          properties_.GetLocalExtendedFeatures(args[1]));
357  send_event_(std::move(command_complete));
358}
359
360void DualModeController::HciWriteSimplePairingMode(
361    UNUSED_ATTR const vector<uint8_t>& args) {
362  LogCommand("Write Simple Pairing Mode");
363  SendCommandCompleteSuccess(HCI_WRITE_SIMPLE_PAIRING_MODE);
364}
365
366void DualModeController::HciWriteLeHostSupport(
367    UNUSED_ATTR const vector<uint8_t>& args) {
368  LogCommand("Write Le Host Support");
369  SendCommandCompleteSuccess(HCI_WRITE_LE_HOST_SUPPORT);
370}
371
372void DualModeController::HciSetEventMask(
373    UNUSED_ATTR const vector<uint8_t>& args) {
374  LogCommand("Set Event Mask");
375  SendCommandCompleteSuccess(HCI_SET_EVENT_MASK);
376}
377
378void DualModeController::HciWriteInquiryMode(const vector<uint8_t>& args) {
379  LogCommand("Write Inquiry Mode");
380  CHECK(args.size() == 2);
381  inquiry_mode_ = args[1];
382  SendCommandCompleteSuccess(HCI_WRITE_INQUIRY_MODE);
383}
384
385void DualModeController::HciWritePageScanType(
386    UNUSED_ATTR const vector<uint8_t>& args) {
387  LogCommand("Write Page Scan Type");
388  SendCommandCompleteSuccess(HCI_WRITE_PAGESCAN_TYPE);
389}
390
391void DualModeController::HciWriteInquiryScanType(
392    UNUSED_ATTR const vector<uint8_t>& args) {
393  LogCommand("Write Inquiry Scan Type");
394  SendCommandCompleteSuccess(HCI_WRITE_INQSCAN_TYPE);
395}
396
397void DualModeController::HciWriteClassOfDevice(
398    UNUSED_ATTR const vector<uint8_t>& args) {
399  LogCommand("Write Class Of Device");
400  SendCommandCompleteSuccess(HCI_WRITE_CLASS_OF_DEVICE);
401}
402
403void DualModeController::HciWritePageTimeout(
404    UNUSED_ATTR const vector<uint8_t>& args) {
405  LogCommand("Write Page Timeout");
406  SendCommandCompleteSuccess(HCI_WRITE_PAGE_TOUT);
407}
408
409void DualModeController::HciWriteDefaultLinkPolicySettings(
410    UNUSED_ATTR const vector<uint8_t>& args) {
411  LogCommand("Write Default Link Policy Settings");
412  SendCommandCompleteSuccess(HCI_WRITE_DEF_POLICY_SETTINGS);
413}
414
415void DualModeController::HciReadLocalName(
416    UNUSED_ATTR const vector<uint8_t>& args) {
417  LogCommand("Get Local Name");
418  std::unique_ptr<EventPacket> command_complete =
419      EventPacket::CreateCommandCompleteReadLocalName(
420          kSuccessStatus, properties_.GetLocalName());
421  send_event_(std::move(command_complete));
422}
423
424void DualModeController::HciWriteLocalName(
425    UNUSED_ATTR const vector<uint8_t>& args) {
426  LogCommand("Write Local Name");
427  SendCommandCompleteSuccess(HCI_CHANGE_LOCAL_NAME);
428}
429
430void DualModeController::HciWriteExtendedInquiryResponse(
431    UNUSED_ATTR const vector<uint8_t>& args) {
432  LogCommand("Write Extended Inquiry Response");
433  SendCommandCompleteSuccess(HCI_WRITE_EXT_INQ_RESPONSE);
434}
435
436void DualModeController::HciWriteVoiceSetting(
437    UNUSED_ATTR const vector<uint8_t>& args) {
438  LogCommand("Write Voice Setting");
439  SendCommandCompleteSuccess(HCI_WRITE_VOICE_SETTINGS);
440}
441
442void DualModeController::HciWriteCurrentIacLap(
443    UNUSED_ATTR const vector<uint8_t>& args) {
444  LogCommand("Write Current IAC LAP");
445  SendCommandCompleteSuccess(HCI_WRITE_CURRENT_IAC_LAP);
446}
447
448void DualModeController::HciWriteInquiryScanActivity(
449    UNUSED_ATTR const vector<uint8_t>& args) {
450  LogCommand("Write Inquiry Scan Activity");
451  SendCommandCompleteSuccess(HCI_WRITE_INQUIRYSCAN_CFG);
452}
453
454void DualModeController::HciWriteScanEnable(
455    UNUSED_ATTR const vector<uint8_t>& args) {
456  LogCommand("Write Scan Enable");
457  SendCommandCompleteSuccess(HCI_WRITE_SCAN_ENABLE);
458}
459
460void DualModeController::HciSetEventFilter(
461    UNUSED_ATTR const vector<uint8_t>& args) {
462  LogCommand("Set Event Filter");
463  SendCommandCompleteSuccess(HCI_SET_EVENT_FILTER);
464}
465
466void DualModeController::HciInquiry(const vector<uint8_t>& args) {
467  // Fake inquiry response for a fake device.
468  const EventPacket::PageScanRepetitionMode kPageScanRepetitionMode =
469      EventPacket::kR0;
470  const uint32_t kClassOfDevice = 0x030201;
471  const uint16_t kClockOffset = 513;
472  BtAddress other_addr;
473  other_addr.FromVector(kOtherDeviceBdAddress);
474
475  LogCommand("Inquiry");
476  state_ = kInquiry;
477  SendCommandStatusSuccess(HCI_INQUIRY);
478  switch (inquiry_mode_) {
479    case (kStandardInquiry): {
480      std::unique_ptr<EventPacket> inquiry_result_evt =
481          EventPacket::CreateInquiryResultEvent(other_addr,
482                                                kPageScanRepetitionMode,
483                                                kClassOfDevice, kClockOffset);
484      send_event_(std::move(inquiry_result_evt));
485      /* TODO: Return responses from modeled devices */
486    } break;
487
488    case (kRssiInquiry):
489      LOG_INFO(LOG_TAG, "RSSI Inquiry Mode currently not supported.");
490      break;
491
492    case (kExtendedOrRssiInquiry): {
493      const std::string name = "Foobar";
494      vector<uint8_t> extended_inquiry_data = {
495          static_cast<uint8_t>(name.length() + 1), 0x09};
496
497      for (size_t i = 0; i < name.length(); i++)
498        extended_inquiry_data.push_back(name[i]);
499      extended_inquiry_data.push_back('\0');
500
501      uint8_t rssi = static_cast<uint8_t>(-20);
502      send_event_(EventPacket::CreateExtendedInquiryResultEvent(
503          other_addr, kPageScanRepetitionMode, kClassOfDevice, kClockOffset,
504          rssi, extended_inquiry_data));
505      /* TODO: Return responses from modeled devices */
506    } break;
507  }
508  AddControllerEvent(std::chrono::milliseconds(args[4] * 1280),
509                     [this]() { DualModeController::InquiryTimeout(); });
510}
511
512void DualModeController::HciInquiryCancel(
513    UNUSED_ATTR const vector<uint8_t>& args) {
514  LogCommand("Inquiry Cancel");
515  CHECK(state_ == kInquiry);
516  state_ = kStandby;
517  SendCommandCompleteSuccess(HCI_INQUIRY_CANCEL);
518}
519
520void DualModeController::InquiryTimeout() {
521  LOG_INFO(LOG_TAG, "InquiryTimer fired");
522  if (state_ == kInquiry) {
523    state_ = kStandby;
524    send_event_(EventPacket::CreateInquiryCompleteEvent(kSuccessStatus));
525  }
526}
527
528void DualModeController::HciDeleteStoredLinkKey(
529    UNUSED_ATTR const vector<uint8_t>& args) {
530  LogCommand("Delete Stored Link Key");
531  /* Check the last octect in |args|. If it is 0, delete only the link key for
532   * the given BD_ADDR. If is is 1, delete all stored link keys. */
533  SendCommandCompleteOnlyStatus(HCI_INQUIRY_CANCEL, kUnknownHciCommand);
534}
535
536void DualModeController::HciRemoteNameRequest(
537    UNUSED_ATTR const vector<uint8_t>& args) {
538  LogCommand("Remote Name Request");
539  SendCommandStatusSuccess(HCI_RMT_NAME_REQUEST);
540}
541
542void DualModeController::HciLeSetEventMask(const vector<uint8_t>& args) {
543  LogCommand("LE SetEventMask");
544  le_event_mask_ = args;
545  SendCommandCompleteSuccess(HCI_BLE_SET_EVENT_MASK);
546}
547
548void DualModeController::HciLeReadBufferSize(
549    UNUSED_ATTR const vector<uint8_t>& args) {
550  std::unique_ptr<EventPacket> command_complete =
551      EventPacket::CreateCommandCompleteLeReadBufferSize(
552          kSuccessStatus, properties_.GetLeDataPacketLength(),
553          properties_.GetTotalNumLeDataPackets());
554  send_event_(std::move(command_complete));
555}
556
557void DualModeController::HciLeReadLocalSupportedFeatures(
558    UNUSED_ATTR const vector<uint8_t>& args) {
559  std::unique_ptr<EventPacket> command_complete =
560      EventPacket::CreateCommandCompleteLeReadLocalSupportedFeatures(
561          kSuccessStatus, properties_.GetLeLocalSupportedFeatures());
562  send_event_(std::move(command_complete));
563}
564
565void DualModeController::HciLeSetRandomAddress(const vector<uint8_t>& args) {
566  LogCommand("LE SetRandomAddress");
567  CHECK(args.size() == 7);
568  vector<uint8_t> new_addr = {args[1], args[2], args[3],
569                              args[4], args[5], args[6]};
570  CHECK(le_random_address_.FromVector(new_addr));
571  SendCommandCompleteSuccess(HCI_BLE_WRITE_RANDOM_ADDR);
572}
573
574void DualModeController::HciLeSetAdvertisingParameters(
575    UNUSED_ATTR const vector<uint8_t>& args) {
576  LogCommand("LE SetAdvertisingParameters");
577  SendCommandCompleteSuccess(HCI_BLE_WRITE_ADV_PARAMS);
578}
579
580void DualModeController::HciLeSetAdvertisingData(
581    UNUSED_ATTR const vector<uint8_t>& args) {
582  LogCommand("LE SetAdvertisingData");
583  SendCommandCompleteSuccess(HCI_BLE_WRITE_ADV_DATA);
584}
585
586void DualModeController::HciLeSetScanParameters(const vector<uint8_t>& args) {
587  LogCommand("LE SetScanParameters");
588  CHECK(args.size() == 8);
589  le_scan_type_ = args[1];
590  le_scan_interval_ = args[2] | (args[3] << 8);
591  le_scan_window_ = args[4] | (args[5] << 8);
592  own_address_type_ = args[6];
593  scanning_filter_policy_ = args[7];
594  SendCommandCompleteSuccess(HCI_BLE_WRITE_SCAN_PARAMS);
595}
596
597void DualModeController::HciLeSetScanEnable(const vector<uint8_t>& args) {
598  LogCommand("LE SetScanEnable");
599  CHECK(args.size() == 3);
600  CHECK(args[0] == 2);
601  le_scan_enable_ = args[1];
602  filter_duplicates_ = args[2];
603  SendCommandCompleteSuccess(HCI_BLE_WRITE_SCAN_ENABLE);
604}
605
606void DualModeController::HciLeReadWhiteListSize(
607    UNUSED_ATTR const vector<uint8_t>& args) {
608  std::unique_ptr<EventPacket> command_complete =
609      EventPacket::CreateCommandCompleteLeReadWhiteListSize(
610          kSuccessStatus, properties_.GetLeWhiteListSize());
611  send_event_(std::move(command_complete));
612}
613
614void DualModeController::HciLeRand(UNUSED_ATTR const vector<uint8_t>& args) {
615  uint64_t random_val = rand();
616  std::unique_ptr<EventPacket> command_complete =
617      EventPacket::CreateCommandCompleteLeRand(kSuccessStatus, random_val);
618  send_event_(std::move(command_complete));
619}
620
621void DualModeController::HciLeReadSupportedStates(
622    UNUSED_ATTR const vector<uint8_t>& args) {
623  std::unique_ptr<EventPacket> command_complete =
624      EventPacket::CreateCommandCompleteLeReadSupportedStates(
625          kSuccessStatus, properties_.GetLeSupportedStates());
626  send_event_(std::move(command_complete));
627}
628
629void DualModeController::HciBleVendorSleepMode(
630    UNUSED_ATTR const vector<uint8_t>& args) {
631  SendCommandCompleteOnlyStatus(HCI_GRP_VENDOR_SPECIFIC | 0x27,
632                                kUnknownHciCommand);
633}
634
635void DualModeController::HciBleVendorCap(
636    UNUSED_ATTR const vector<uint8_t>& args) {
637  std::unique_ptr<EventPacket> command_complete =
638      EventPacket::CreateCommandCompleteLeVendorCap(
639          kSuccessStatus, properties_.GetLeVendorCap());
640  send_event_(std::move(command_complete));
641}
642
643void DualModeController::HciBleVendorMultiAdv(
644    UNUSED_ATTR const vector<uint8_t>& args) {
645  SendCommandCompleteOnlyStatus(HCI_BLE_MULTI_ADV_OCF, kUnknownHciCommand);
646}
647
648void DualModeController::HciBleVendor155(
649    UNUSED_ATTR const vector<uint8_t>& args) {
650  SendCommandCompleteOnlyStatus(HCI_GRP_VENDOR_SPECIFIC | 0x155,
651                                kUnknownHciCommand);
652}
653
654void DualModeController::HciBleVendor157(
655    UNUSED_ATTR const vector<uint8_t>& args) {
656  SendCommandCompleteOnlyStatus(HCI_GRP_VENDOR_SPECIFIC | 0x157,
657                                kUnknownHciCommand);
658}
659
660void DualModeController::HciBleEnergyInfo(
661    UNUSED_ATTR const vector<uint8_t>& args) {
662  SendCommandCompleteOnlyStatus(HCI_BLE_ENERGY_INFO_OCF, kUnknownHciCommand);
663}
664
665void DualModeController::HciBleExtendedScanParams(
666    UNUSED_ATTR const vector<uint8_t>& args) {
667  SendCommandCompleteOnlyStatus(HCI_BLE_EXTENDED_SCAN_PARAMS_OCF,
668                                kUnknownHciCommand);
669}
670
671DualModeController::Properties::Properties(const std::string& file_name)
672    : acl_data_packet_size_(1024),
673      sco_data_packet_size_(255),
674      num_acl_data_packets_(10),
675      num_sco_data_packets_(10),
676      version_(4),
677      revision_(1),
678      lmp_pal_version_(0),
679      manufacturer_name_(0),
680      lmp_pal_subversion_(0),
681      le_data_packet_length_(27),
682      num_le_data_packets_(15),
683      le_white_list_size_(15) {
684  std::string properties_raw;
685
686  local_extended_features_ = {0xffffffffffffffff, 0x7};
687
688  CHECK(address_.FromString("01:02:03:04:05:06"));
689  local_name_ = "DefaultName";
690
691  supported_codecs_ = {1};
692  vendor_specific_codecs_ = {};
693
694  for (int i = 0; i < 64; i++) local_supported_commands_.push_back(0xff);
695
696  le_supported_features_ = 0x1f;
697  le_supported_states_ = 0x3ffffffffff;
698  le_vendor_cap_ = {0x05, 0x01, 0x00, 0x04, 0x80, 0x01, 0x10,
699                    0x01, 0x60, 0x00, 0x0a, 0x00, 0x01, 0x01};
700
701  LOG_INFO(LOG_TAG, "Reading controller properties from %s.",
702           file_name.c_str());
703  if (!base::ReadFileToString(base::FilePath(file_name), &properties_raw)) {
704    LOG_ERROR(LOG_TAG, "Error reading controller properties from file.");
705    return;
706  }
707
708  std::unique_ptr<base::Value> properties_value_ptr =
709      base::JSONReader::Read(properties_raw);
710  if (properties_value_ptr.get() == nullptr)
711    LOG_INFO(LOG_TAG,
712             "Error controller properties may consist of ill-formed JSON.");
713
714  // Get the underlying base::Value object, which is of type
715  // base::Value::TYPE_DICTIONARY, and read it into member variables.
716  base::Value& properties_dictionary = *(properties_value_ptr.get());
717  base::JSONValueConverter<DualModeController::Properties> converter;
718
719  if (!converter.Convert(properties_dictionary, this))
720    LOG_INFO(LOG_TAG,
721             "Error converting JSON properties into Properties object.");
722}
723
724// static
725void DualModeController::Properties::RegisterJSONConverter(
726    base::JSONValueConverter<DualModeController::Properties>* converter) {
727// TODO(dennischeng): Use RegisterIntField() here?
728#define REGISTER_UINT8_T(field_name, field) \
729  converter->RegisterCustomField<uint8_t>(  \
730      field_name, &DualModeController::Properties::field, &ParseUint8t);
731#define REGISTER_UINT16_T(field_name, field) \
732  converter->RegisterCustomField<uint16_t>(  \
733      field_name, &DualModeController::Properties::field, &ParseUint16t);
734  REGISTER_UINT16_T("AclDataPacketSize", acl_data_packet_size_);
735  REGISTER_UINT8_T("ScoDataPacketSize", sco_data_packet_size_);
736  REGISTER_UINT16_T("NumAclDataPackets", num_acl_data_packets_);
737  REGISTER_UINT16_T("NumScoDataPackets", num_sco_data_packets_);
738  REGISTER_UINT8_T("Version", version_);
739  REGISTER_UINT16_T("Revision", revision_);
740  REGISTER_UINT8_T("LmpPalVersion", lmp_pal_version_);
741  REGISTER_UINT16_T("ManufacturerName", manufacturer_name_);
742  REGISTER_UINT16_T("LmpPalSubversion", lmp_pal_subversion_);
743#undef REGISTER_UINT8_T
744#undef REGISTER_UINT16_T
745}
746
747}  // namespace test_vendor_lib
748