Weave Packet Generator

components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.cc

Index: components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.cc
diff --git a/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.cc b/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b6749d164ecc875f122ef4722a9e29731f834535
--- /dev/null
+++ b/components/proximity_auth/ble/bluetooth_low_energy_weave_packet_generator.cc
@@ -0,0 +1,210 @@
+// 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 {
+
+typedef proximity_auth::BluetoothLowEnergyWeavePacketGenerator::Packet Packet;
+
+const uint16_t kMinSupportedWeaveVersion = 1;
+const uint16_t kMaxSupportedWeaveVersion = 1;
+const uint16_t kServerWeaveVersion = 1;
+const uint16_t kMinConnectionRequestSize = 7;
+const uint16_t kMinConnectionResponseSize = 5;
+const uint16_t kMinConnectionCloseSize = 3;
+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
+
+namespace proximity_auth {
+
+// static.
+BluetoothLowEnergyWeavePacketGenerator::Factory*
+    BluetoothLowEnergyWeavePacketGenerator::Factory::factory_instance_ =
+        nullptr;
+
+// static.
+std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator>
+BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance() {
+  if (factory_instance_ == nullptr) {
+    factory_instance_ = new Factory();
+  }
+  return factory_instance_->BuildInstance();
+}
+
+// static.
+void BluetoothLowEnergyWeavePacketGenerator::Factory::SetInstanceForTesting(
+    Factory* factory) {
+  factory_instance_ = factory;
+}
+
+std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator>
+BluetoothLowEnergyWeavePacketGenerator::Factory::BuildInstance() {
+  return std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator>(
+      new BluetoothLowEnergyWeavePacketGenerator());
+}
+
+BluetoothLowEnergyWeavePacketGenerator::BluetoothLowEnergyWeavePacketGenerator()
+    : packet_size_(kDefaultDataPacketSize), packet_number_(0) {}
+
+Packet BluetoothLowEnergyWeavePacketGenerator::CreateConnectionRequest() {
+  Packet packet = CreateControlPacket(kMinConnectionRequestSize);
+
+  SetControlCommand(ControlCommand::CONNECTION_REQUEST, &packet);
+  SetShortField(1, kMinSupportedWeaveVersion, &packet);
+  SetShortField(3, kMaxSupportedWeaveVersion, &packet);
+  SetShortField(5, kMaxSupportedPacketSize, &packet);
+
+  return packet;
+}
+
+Packet BluetoothLowEnergyWeavePacketGenerator::CreateConnectionResponse() {
+  Packet packet = CreateControlPacket(kMinConnectionResponseSize);
+
+  SetControlCommand(ControlCommand::CONNECTION_RESPONSE, &packet);
+  SetShortField(1, kServerWeaveVersion, &packet);
+  SetShortField(3, packet_size_, &packet);
+
+  return packet;
+}
+
+Packet BluetoothLowEnergyWeavePacketGenerator::CreateConnectionClose(
+    ReasonForClose reason_for_close) {
+  Packet packet = CreateControlPacket(kMinConnectionCloseSize);
+
+  SetControlCommand(ControlCommand::CONNECTION_CLOSE, &packet);
+  SetShortField(1, reason_for_close, &packet);
+
+  return packet;
+}
+
+Packet BluetoothLowEnergyWeavePacketGenerator::CreateControlPacket(
+    uint16_t size) {
+  Packet packet(size, 0);
+
+  // Packet is a control packet.
+  SetPacketTypeBit(PacketType::CONTROL, &packet);
+  SetPacketCounter(&packet);
+
+  return packet;
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetDataPacketSize(uint32_t size) {
+  DCHECK(size >= kDefaultDataPacketSize);
+  packet_size_ = size;
+}
+
+std::vector<Packet> BluetoothLowEnergyWeavePacketGenerator::EncodeDataMessage(
+    std::string message) {
+  DCHECK(!message.empty());
+
+  // 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 packet_payload_size = packet_size_ - 1;
+
+  uint32_t message_length = message.length();
+  // (packet_payload_size - 1) is used to enforce rounding up.
+  uint32_t num_packets =
+      (message_length + (packet_payload_size - 1)) / packet_payload_size;
+
+  std::vector<Packet> weave_message(num_packets);
+
+  const char* byte_message = message.c_str();
+
+  for (uint32_t i = 0; i < num_packets; ++i) {
+    Packet* packet = &weave_message[i];
+    uint32_t begin = packet_payload_size * i;
+    uint32_t end = std::min(begin + packet_payload_size, message_length);
+
+    packet->push_back(0);
+
+    SetPacketTypeBit(PacketType::DATA, packet);
+    SetPacketCounter(packet);
+
+    for (uint32_t i = begin; i < end; ++i) {
+      packet->push_back(byte_message[i]);
+    }
+  }
+
+  // Guaranteed to have at least one packet since message is not empty.
+  SetDataFirstBit(&weave_message[0]);
+  SetDataLastBit(&weave_message[num_packets - 1]);
+
+  return weave_message;
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetShortField(uint32_t byte_offset,

[Kyle Horimoto, 2016/06/21 17:17:31]

Please use htons() here as well, thanks!

+                                                           uint16_t val,
+                                                           Packet* packet) {
+  DCHECK(packet);
+  DCHECK_LT(byte_offset, packet->size());
+  DCHECK_LT(byte_offset + 1, packet->size());
+
+  uint8_t upper = (val >> 8) & 0xFF;
+  uint8_t lower = val & 0xFF;
+
+  packet->at(byte_offset) = lower;
+  packet->at(byte_offset + 1) = upper;
+}
+
+void BluetoothLowEnergyWeavePacketGenerator::SetPacketTypeBit(PacketType type,
+                                                              Packet* packet) {
+  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(
+    ControlCommand command,
+    Packet* packet) {
+  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