Weave Packet Generator

components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.h"
+
+#include <string.h>
+
+#include <algorithm>
+
+#include "base/logging.h"
+
+namespace proximity_auth {
+
+namespace {
+
+const uint16_t kMinSupportedWeaveVersion = 1;
+const uint16_t kMaxSupportedWeaveVersion = 1;
+const uint16_t kServerWeaveVersion = 1;
+const uint16_t kControlPacketSize = 20;
+const uint32_t kDefaultDataPacketSize = 20;
+
+// Max packet size is 0, which means defer the decision to the server.
+const uint16_t kMaxSupportedPacketSize = 0;
+const uint8_t kMaxPacketCounter = 8;
+}  // namespace
+
+BluetoothLowEnergyWeavePacketGenerator::Factory*
+    BluetoothLowEnergyWeavePacketGenerator::Factory::factory_instance_ =
+        nullptr;
+
+std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator>
+BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance() {
+  if (factory_instance_ == nullptr) {
+    factory_instance_ = new Factory();
+  }
+  return std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator>(
+      factory_instance_->BuildInstance());
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::Factory::SetInstanceForTesting(
+    Factory* factory) {
+  factory_instance_ = factory;
+}
+
+BluetoothLowEnergyWeavePacketGenerator*
+BluetoothLowEnergyWeavePacketGenerator::Factory::BuildInstance() {
+  return new BluetoothLowEnergyWeavePacketGenerator();
+}
+
+BluetoothLowEnergyWeavePacketGenerator::BluetoothLowEnergyWeavePacketGenerator()
+    : packet_size_(kDefaultDataPacketSize), packet_number_(0) {}
+
+std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator::Packet>
+BluetoothLowEnergyWeavePacketGenerator::CreateConnectionRequest() {
+  Packet* packet = CreateControlPacket();
+
+  SetControlCommand(packet, ControlPacketCommand::CONNECTION_REQUEST);
+  SetShortField(packet, 1, kMinSupportedWeaveVersion);
+  SetShortField(packet, 3, kMaxSupportedWeaveVersion);
+  SetShortField(packet, 5, kMaxSupportedPacketSize);
+
+  return std::unique_ptr<Packet>(packet);
+}
+
+std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator::Packet>
+BluetoothLowEnergyWeavePacketGenerator::CreateConnectionResponse() {
+  Packet* packet = CreateControlPacket();
+
+  SetControlCommand(packet, ControlPacketCommand::CONNECTION_RESPONSE);
+  SetShortField(packet, 1, kServerWeaveVersion);
+  SetShortField(packet, 3, packet_size_);
+
+  return std::unique_ptr<Packet>(packet);
+}
+
+std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator::Packet>
+BluetoothLowEnergyWeavePacketGenerator::CreateConnectionClose(
+    ReasonForClose reason_for_close) {
+  Packet* packet = CreateControlPacket();
+
+  SetControlCommand(packet, ControlPacketCommand::CONNECTION_CLOSE);
+  SetShortField(packet, 1, reason_for_close);
+
+  return std::unique_ptr<Packet>(packet);
+}
+
+BluetoothLowEnergyWeavePacketGenerator::Packet*
+BluetoothLowEnergyWeavePacketGenerator::CreateControlPacket() {
+  Packet* packet = new Packet(kControlPacketSize, 0);
+
+  // Packet is a control packet.
+  SetPacketTypeBit(packet, PacketType::CONTROL);
+  SetPacketCounter(packet);
+
+  return packet;
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetDataPacketSize(uint32_t size) {
+  packet_size_ = size;
+}
+
+std::unique_ptr<std::vector<BluetoothLowEnergyWeavePacketGenerator::Packet>>
+BluetoothLowEnergyWeavePacketGenerator::EncodeDataMessage(std::string message) {
+  // The first byte of a packet is used by the uWeave protocol,
+  // hence the payload is 1 byte smaller than the packet size.
+  uint32_t payload_size = packet_size_ - 1;

[Kyle Horimoto, 2016/06/09 22:55:43]

s/payload_size/payload_size_per_packet/

[jingxuy, 2016/06/11 00:49:32]

Done.

+
+  // The message's length is the length of the string plus '\0'.
+  // (payload_size - 1) is used to enforce rounding up the number of packets
+  // (message.length() + 1) + (payload_size - 1) / (payload_size).
+  uint32_t num_packets = (message.length() + payload_size) / payload_size;

[Kyle Horimoto, 2016/06/09 22:55:43]

nit: Please just use the computation you wrote above in the comment. It will
make your code more readable. And don't worry, a compiler pass will optimize
your code so it won't be any more inefficient.

[jingxuy, 2016/06/11 00:49:32]

Done.

+
+  std::vector<Packet>* weave_message = new std::vector<Packet>(num_packets);
+
+  uint32_t last_byte = message.length() + 1;

[Kyle Horimoto, 2016/06/09 22:55:43]

This name is confusing because it implies that this is the value of the last
byte. How about num_bytes_in_message?

[jingxuy, 2016/06/11 00:49:32]

Done.

+  const char* byte_message = message.c_str();
+
+  for (uint32_t i = 0; i < num_packets; ++i) {
+    Packet* packet = &weave_message->at(i);
+    uint32_t begin = payload_size * i;

[Kyle Horimoto, 2016/06/09 22:55:43]

nit: Move the begin/end calculations to right before you use them.

[jingxuy, 2016/06/11 00:49:32]

I don't understand the comment.

+    uint32_t end = std::min(begin + payload_size, last_byte);
+
+    packet->push_back(0);
+
+    SetPacketTypeBit(packet, PacketType::DATA);
+    SetPacketCounter(packet);
+
+    for (uint32_t i = begin; i < end; ++i) {
+      packet->push_back(byte_message[i]);
+    }
+  }
+
+  // Since even empty string has \0, weave_message is guaranteed to be nonempty.
+  SetDataFirstBit(&weave_message->at(0));
+  SetDataLastBit(&weave_message->at(num_packets - 1));
+
+  return std::unique_ptr<std::vector<Packet>>(weave_message);
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetShortField(Packet* packet,
+                                                           uint32_t index,

[Kyle Horimoto, 2016/06/09 22:55:43]

s/index/byte_offset

[jingxuy, 2016/06/11 00:49:32]

Done.

+                                                           uint16_t val) {
+  DCHECK(packet);
+  DCHECK_LT(index, packet->size());
+  DCHECK_LT(index + 1, packet->size());
+
+  uint8_t upper = val >> 8 & 0xFF;

[Kyle Horimoto, 2016/06/09 22:55:43]

nit: Use parentheses to make it clear which operation is performed first.

[jingxuy, 2016/06/11 00:49:32]

Done.

+  uint8_t lower = val & 0xFF;
+
+  packet->at(index) = lower;
+  packet->at(index + 1) = upper;
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetPacketTypeBit(Packet* packet,
+                                                              PacketType type) {
+  DCHECK(packet);
+  DCHECK(!packet->empty());
+
+  // Type bit is the highest bit of the first byte of the packet.
+  // So clear the highest bit and set it according to val.
+  packet->at(0) = (packet->at(0) & 0x7F) | (type << 7);
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetControlCommand(
+    Packet* packet,
+    ControlPacketCommand command) {
+  DCHECK(packet);
+  DCHECK(!packet->empty());
+
+  // Control Command is the lower 4 bits of the packet's first byte.
+  // So clear the lower 4 bites and set it according to val.
+  packet->at(0) = (packet->at(0) & 0xF0) | command;
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetPacketCounter(Packet* packet) {
+  DCHECK(packet);
+  DCHECK(!packet->empty());
+  uint8_t counter = packet_number_ % kMaxPacketCounter;
+
+  // Packet counter is the bits 4, 5, and 6 of the packet's first byte.
+  // So clear those bits and set them according to current packet counter
+  // modular max packet counter.
+  packet->at(0) = (packet->at(0) & 0x8F) | (counter << 4);
+  packet_number_++;
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetDataFirstBit(Packet* packet) {
+  DCHECK(packet);
+  DCHECK(!packet->empty());
+
+  // First bit is bit 3 of the packet's first byte and set it to 1.
+  packet->at(0) = packet->at(0) | (1 << 3);
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetDataLastBit(Packet* packet) {
+  DCHECK(packet);
+  DCHECK(!packet->empty());
+
+  // Last bit is the bit 2 of the packet's first byte and set it to 1.
+  packet->at(0) = packet->at(0) | (1 << 2);
+}
+
+}  // namespace proximity_auth