| OLD | NEW |
| (Empty) |
| 1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/proximity_auth/ble/bluetooth_low_energy_weave_packet_genera
tor.h" | |
| 6 | |
| 7 #ifdef OS_WIN | |
| 8 #include <winsock2.h> | |
| 9 #else | |
| 10 #include <netinet/in.h> | |
| 11 #endif | |
| 12 | |
| 13 #include <string.h> | |
| 14 | |
| 15 #include <algorithm> | |
| 16 | |
| 17 #include "base/logging.h" | |
| 18 | |
| 19 namespace proximity_auth { | |
| 20 namespace weave { | |
| 21 | |
| 22 // static. | |
| 23 std::shared_ptr<BluetoothLowEnergyWeavePacketGenerator::Factory> | |
| 24 BluetoothLowEnergyWeavePacketGenerator::Factory::factory_instance_ = | |
| 25 nullptr; | |
| 26 | |
| 27 // static. | |
| 28 std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> | |
| 29 BluetoothLowEnergyWeavePacketGenerator::Factory::NewInstance() { | |
| 30 if (!factory_instance_) { | |
| 31 factory_instance_.reset(new Factory()); | |
| 32 } | |
| 33 return factory_instance_->BuildInstance(); | |
| 34 } | |
| 35 | |
| 36 // static. | |
| 37 void BluetoothLowEnergyWeavePacketGenerator::Factory::SetInstanceForTesting( | |
| 38 std::shared_ptr<Factory> factory) { | |
| 39 factory_instance_ = factory; | |
| 40 } | |
| 41 | |
| 42 std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> | |
| 43 BluetoothLowEnergyWeavePacketGenerator::Factory::BuildInstance() { | |
| 44 return std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator>( | |
| 45 new BluetoothLowEnergyWeavePacketGenerator()); | |
| 46 } | |
| 47 | |
| 48 BluetoothLowEnergyWeavePacketGenerator::BluetoothLowEnergyWeavePacketGenerator() | |
| 49 : max_packet_size_(kDefaultMaxPacketSize), next_packet_counter_(0) {} | |
| 50 | |
| 51 Packet BluetoothLowEnergyWeavePacketGenerator::CreateConnectionRequest() { | |
| 52 Packet packet(kMinConnectionRequestSize, 0); | |
| 53 | |
| 54 SetPacketTypeBit(PacketType::CONTROL, &packet); | |
| 55 // Since it only make sense for connection request to be the 0th packet, | |
| 56 // resets the packet counter. | |
| 57 next_packet_counter_ = 1; | |
| 58 SetControlCommand(ControlCommand::CONNECTION_REQUEST, &packet); | |
| 59 SetShortField(1, kWeaveVersion, &packet); | |
| 60 SetShortField(3, kWeaveVersion, &packet); | |
| 61 SetShortField(5, kSelectMaxPacketSize, &packet); | |
| 62 | |
| 63 return packet; | |
| 64 } | |
| 65 | |
| 66 Packet BluetoothLowEnergyWeavePacketGenerator::CreateConnectionResponse() { | |
| 67 Packet packet(kMinConnectionResponseSize, 0); | |
| 68 | |
| 69 SetPacketTypeBit(PacketType::CONTROL, &packet); | |
| 70 // Since it only make sense for connection response to be the 0th packet, | |
| 71 // resets the next packet counter. | |
| 72 next_packet_counter_ = 1; | |
| 73 SetControlCommand(ControlCommand::CONNECTION_RESPONSE, &packet); | |
| 74 SetShortField(1, kWeaveVersion, &packet); | |
| 75 SetShortField(3, max_packet_size_, &packet); | |
| 76 | |
| 77 return packet; | |
| 78 } | |
| 79 | |
| 80 Packet BluetoothLowEnergyWeavePacketGenerator::CreateConnectionClose( | |
| 81 ReasonForClose reason_for_close) { | |
| 82 Packet packet(kMaxConnectionCloseSize, 0); | |
| 83 | |
| 84 SetPacketTypeBit(PacketType::CONTROL, &packet); | |
| 85 SetPacketCounter(&packet); | |
| 86 SetControlCommand(ControlCommand::CONNECTION_CLOSE, &packet); | |
| 87 SetShortField(1, reason_for_close, &packet); | |
| 88 | |
| 89 return packet; | |
| 90 } | |
| 91 | |
| 92 void BluetoothLowEnergyWeavePacketGenerator::SetMaxPacketSize(uint16_t size) { | |
| 93 DCHECK(size >= kDefaultMaxPacketSize); | |
| 94 max_packet_size_ = size; | |
| 95 } | |
| 96 | |
| 97 std::vector<Packet> BluetoothLowEnergyWeavePacketGenerator::EncodeDataMessage( | |
| 98 std::string message) { | |
| 99 DCHECK(!message.empty()); | |
| 100 | |
| 101 // The first byte of a packet is used by the uWeave protocol, | |
| 102 // hence the payload is 1 byte smaller than the packet size. | |
| 103 uint32_t packet_payload_size = max_packet_size_ - 1; | |
| 104 | |
| 105 uint32_t message_length = message.length(); | |
| 106 // (packet_payload_size - 1) is used to enforce rounding up. | |
| 107 uint32_t num_packets = | |
| 108 (message_length + (packet_payload_size - 1)) / packet_payload_size; | |
| 109 | |
| 110 std::vector<Packet> weave_message(num_packets); | |
| 111 | |
| 112 const char* byte_message = message.c_str(); | |
| 113 | |
| 114 for (uint32_t i = 0; i < num_packets; ++i) { | |
| 115 Packet* packet = &weave_message[i]; | |
| 116 uint32_t begin = packet_payload_size * i; | |
| 117 uint32_t end = std::min(begin + packet_payload_size, message_length); | |
| 118 | |
| 119 packet->push_back(0); | |
| 120 | |
| 121 SetPacketTypeBit(PacketType::DATA, packet); | |
| 122 SetPacketCounter(packet); | |
| 123 | |
| 124 for (uint32_t j = begin; j < end; ++j) { | |
| 125 packet->push_back(byte_message[j]); | |
| 126 } | |
| 127 } | |
| 128 | |
| 129 // Guaranteed to have at least one packet since message is not empty. | |
| 130 SetDataFirstBit(&weave_message[0]); | |
| 131 SetDataLastBit(&weave_message[num_packets - 1]); | |
| 132 | |
| 133 return weave_message; | |
| 134 } | |
| 135 | |
| 136 void BluetoothLowEnergyWeavePacketGenerator::SetShortField(uint32_t byte_offset, | |
| 137 uint16_t val, | |
| 138 Packet* packet) { | |
| 139 DCHECK(packet); | |
| 140 DCHECK_LT(byte_offset, packet->size()); | |
| 141 DCHECK_LT(byte_offset + 1, packet->size()); | |
| 142 | |
| 143 uint16_t network_val = htons(val); | |
| 144 uint8_t* network_val_ptr = reinterpret_cast<uint8_t*>(&network_val); | |
| 145 | |
| 146 packet->at(byte_offset) = network_val_ptr[0]; | |
| 147 packet->at(byte_offset + 1) = network_val_ptr[1]; | |
| 148 } | |
| 149 | |
| 150 void BluetoothLowEnergyWeavePacketGenerator::SetPacketTypeBit(PacketType type, | |
| 151 Packet* packet) { | |
| 152 DCHECK(packet); | |
| 153 DCHECK(!packet->empty()); | |
| 154 | |
| 155 // Type bit is the highest bit of the first byte of the packet. | |
| 156 // So clear the highest bit and set it according to val. | |
| 157 packet->at(0) = (packet->at(0) & 0x7F) | (type << 7); | |
| 158 } | |
| 159 | |
| 160 void BluetoothLowEnergyWeavePacketGenerator::SetControlCommand( | |
| 161 ControlCommand command, | |
| 162 Packet* packet) { | |
| 163 DCHECK(packet); | |
| 164 DCHECK(!packet->empty()); | |
| 165 | |
| 166 // Control Command is the lower 4 bits of the packet's first byte. | |
| 167 // So clear the lower 4 bites and set it according to val. | |
| 168 packet->at(0) = (packet->at(0) & 0xF0) | command; | |
| 169 } | |
| 170 | |
| 171 void BluetoothLowEnergyWeavePacketGenerator::SetPacketCounter(Packet* packet) { | |
| 172 DCHECK(packet); | |
| 173 DCHECK(!packet->empty()); | |
| 174 uint8_t counter = next_packet_counter_ % kMaxPacketCounter; | |
| 175 | |
| 176 // Packet counter is the bits 4, 5, and 6 of the packet's first byte. | |
| 177 // So clear those bits and set them according to current packet counter | |
| 178 // modular max packet counter. | |
| 179 packet->at(0) = (packet->at(0) & 0x8F) | (counter << 4); | |
| 180 next_packet_counter_++; | |
| 181 } | |
| 182 | |
| 183 void BluetoothLowEnergyWeavePacketGenerator::SetDataFirstBit(Packet* packet) { | |
| 184 DCHECK(packet); | |
| 185 DCHECK(!packet->empty()); | |
| 186 | |
| 187 // First bit is bit 3 of the packet's first byte and set it to 1. | |
| 188 packet->at(0) = packet->at(0) | (1 << 3); | |
| 189 } | |
| 190 | |
| 191 void BluetoothLowEnergyWeavePacketGenerator::SetDataLastBit(Packet* packet) { | |
| 192 DCHECK(packet); | |
| 193 DCHECK(!packet->empty()); | |
| 194 | |
| 195 // Last bit is the bit 2 of the packet's first byte and set it to 1. | |
| 196 packet->at(0) = packet->at(0) | (1 << 2); | |
| 197 } | |
| 198 | |
| 199 } // namespace weave | |
| 200 | |
| 201 } // namespace proximity_auth | |
| OLD | NEW |