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"

[sacomoto, 2016/06/13 16:05:19]

Is this header really necesary?

[jingxuy, 2016/06/17 00:56:45]

it is used for DCHECK

+
+namespace {
+
+const uint16_t kMinSupportedWeaveVersion = 1;
+const uint16_t kMaxSupportedWeaveVersion = 1;
+const uint16_t kServerWeaveVersion = 1;

[sacomoto, 2016/06/13 16:05:19]

This constant should not be necessary. See my comment for the
|CreateConnectionResponse()| int header file.

[Kyle Horimoto, 2016/06/13 17:55:53]

Regarding your other comment: you are certainly correct that we need to ensure
that we support the min/max versions, but we also only implement v1. So, I think
the right thing to do is check that v1 is >= the min version passed and <= the
max version passed, then just use it.

[jingxuy, 2016/06/17 00:56:45]

see my comment in the header file.

+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
+
+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 std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator>(
+      factory_instance_->BuildInstance());
+}
+
+// static.
+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, ControlCommand::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, ControlCommand::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, ControlCommand::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 packet_payload_size = packet_size_ - 1;
+
+  // The message's length is the length of the string plus '\0'.

[sacomoto, 2016/06/13 16:05:18]

The uWeave protocol does not require the bytes sent in a data packet to be
terminated by '\0'. The data packet contains raw bytes, not C strings. 

[jingxuy, 2016/06/17 00:56:45]

I had a misconception thinking that we are sending the whole string. You are
right that the string is a byte array without the '\0'

+  // (packet_payload_size - 1) is used to enforce rounding up.
+  uint32_t num_packets = ((message.length() + 1) + (packet_payload_size - 1)) /
+                         packet_payload_size;
+
+  std::vector<Packet>* weave_message = new std::vector<Packet>(num_packets);
+
+  uint32_t message_num_bytes = message.length() + 1;
+  const char* byte_message = message.c_str();

[sacomoto, 2016/06/13 16:05:19]

You should not append the '\0' at the end of the message. This is probably
harmless, as the other implementations will most likely simply ignore it, but we
should stick to the protocol definition.

DCHECK(messsage.size() != 0) in the beginning of the method or return nil in
that case. And, more importantly, do not append '\0' to end of the packet.  

[jingxuy, 2016/06/17 00:56:45]

Done.

+
+  for (uint32_t i = 0; i < num_packets; ++i) {
+    Packet* packet = &weave_message->at(i);
+    uint32_t begin = packet_payload_size * i;
+    uint32_t end = std::min(begin + packet_payload_size, message_num_bytes);
+
+    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 byte_offset,
+                                                           uint16_t val) {
+  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(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,
+    ControlCommand 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