Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0c675904 authored by Myles Watson's avatar Myles Watson
Browse files

BitInserter: Add byte observer for checksums 

Test: bluetooth_test_gd --gtest_filter=*BitInserter*
Change-Id: I9ef5bc5951244279fc142127a5c3c9a54c4eaf5c
parent 107159fb

system/gd/packet/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -2,6 +2,8 @@ filegroup { 
    name: "BluetoothPacketSources",

    srcs: [

        "bit_inserter.cc",

	"byte_inserter.cc",

	"byte_observer.cc",

        "iterator.cc",

        "packet_view.cc",

        "raw_builder.cc",

system/gd/packet/bit_inserter.cc

+20 −127
Original line number Diff line number Diff line
@@ -14,147 +14,40 @@ 
 * limitations under the License.

 */



#include "packet/iterator.h"

#include "packet/bit_inserter.h"



#include "os/log.h"



namespace bluetooth {

namespace packet {



template <bool little_endian>

Iterator<little_endian>::Iterator(std::forward_list<View> data, size_t offset) {

  data_ = data;

  index_ = offset;

  length_ = 0;

  for (auto& view : data) {

    length_ += view.size();

  }

}



template <bool little_endian>

Iterator<little_endian> Iterator<little_endian>::operator+(int offset) {

  auto itr(*this);



  return itr += offset;

}



template <bool little_endian>

Iterator<little_endian>& Iterator<little_endian>::operator+=(int offset) {

  index_ += offset;

  return *this;

}



template <bool little_endian>

Iterator<little_endian> Iterator<little_endian>::operator++(int) {

  auto itr(*this);

  index_++;

  return itr;

}



template <bool little_endian>

Iterator<little_endian>& Iterator<little_endian>::operator++() {

  index_++;

  return *this;

}



template <bool little_endian>

Iterator<little_endian> Iterator<little_endian>::operator-(int offset) {

  auto itr(*this);

BitInserter::BitInserter(std::vector<uint8_t>& vector) : ByteInserter(vector) {}



  return itr -= offset;

BitInserter::~BitInserter() {

  ASSERT(num_saved_bits_ == 0);

}



template <bool little_endian>

int Iterator<little_endian>::operator-(Iterator<little_endian>& itr) {

  return index_ - itr.index_;

}



template <bool little_endian>

Iterator<little_endian>& Iterator<little_endian>::operator-=(int offset) {

  index_ -= offset;



  return *this;

void BitInserter::insert_bits(uint8_t byte, size_t num_bits) {

  size_t total_bits = num_bits + num_saved_bits_;

  uint16_t new_value = saved_bits_ | (static_cast<uint16_t>(byte) << num_saved_bits_);

  if (total_bits >= 8) {

    uint8_t new_byte = static_cast<uint8_t>(new_value);

    ByteInserter::insert_byte(new_byte);

    total_bits -= 8;

    new_value = new_value >> 8;

  }



template <bool little_endian>

Iterator<little_endian> Iterator<little_endian>::operator--(int) {

  auto itr(*this);

  if (index_ != 0) index_--;



  return itr;

  num_saved_bits_ = total_bits;

  uint8_t mask = 0xff >> (8 - num_saved_bits_);

  saved_bits_ = static_cast<uint8_t>(new_value) & mask;

}



template <bool little_endian>

Iterator<little_endian>& Iterator<little_endian>::operator--() {

  if (index_ != 0) index_--;



  return *this;

void BitInserter::insert_byte(uint8_t byte) {

  insert_bits(byte, 8);

}



template <bool little_endian>

Iterator<little_endian>& Iterator<little_endian>::operator=(const Iterator<little_endian>& itr) {

  data_ = itr.data_;

  index_ = itr.index_;



  return *this;

}



template <bool little_endian>

bool Iterator<little_endian>::operator==(const Iterator<little_endian>& itr) const {

  return index_ == itr.index_;

}



template <bool little_endian>

bool Iterator<little_endian>::operator!=(const Iterator<little_endian>& itr) const {

  return !(*this == itr);

}



template <bool little_endian>

bool Iterator<little_endian>::operator<(const Iterator<little_endian>& itr) const {

  return index_ < itr.index_;

}



template <bool little_endian>

bool Iterator<little_endian>::operator>(const Iterator<little_endian>& itr) const {

  return index_ > itr.index_;

}



template <bool little_endian>

bool Iterator<little_endian>::operator<=(const Iterator<little_endian>& itr) const {

  return index_ <= itr.index_;

}



template <bool little_endian>

bool Iterator<little_endian>::operator>=(const Iterator<little_endian>& itr) const {

  return index_ >= itr.index_;

}



template <bool little_endian>

uint8_t Iterator<little_endian>::operator*() const {

  ASSERT_LOG(index_ < length_, "Index %zu out of bounds: %zu", index_, length_);

  size_t index = index_;



  for (auto view : data_) {

    if (index < view.size()) {

      return view[index];

    }

    index -= view.size();

  }

  ASSERT_LOG(false, "Out of fragments searching for index %zu", index_);

  return 0;

}



template <bool little_endian>

size_t Iterator<little_endian>::NumBytesRemaining() const {

  if (length_ > index_) {

    return length_ - index_;

  } else {

    return 0;

  }

bool BitInserter::IsByteAligned() {

  return num_saved_bits_ == 0;

}



// Explicit instantiations for both types of Iterators.

template class Iterator<true>;

template class Iterator<false>;

}  // namespace packet

}  // namespace bluetooth

system/gd/packet/bit_inserter.h

+7 −25
Original line number Diff line number Diff line
@@ -21,39 +21,21 @@ 
#include <memory>

#include <vector>



#include "os/log.h"

#include "packet/byte_inserter.h"



namespace bluetooth {

namespace packet {



class BitInserter : public std::back_insert_iterator<std::vector<uint8_t>> {

class BitInserter : public ByteInserter {

 public:

  BitInserter(std::vector<uint8_t>& vector) : std::back_insert_iterator<std::vector<uint8_t>>(vector) {}

  virtual ~BitInserter() {

    ASSERT(num_saved_bits_ == 0);

  }

  BitInserter(std::vector<uint8_t>& vector);

  virtual ~BitInserter();



  void insert_bits(uint8_t byte, size_t num_bits) {

    size_t total_bits = num_bits + num_saved_bits_;

    uint16_t new_value = saved_bits_ | (static_cast<uint16_t>(byte) << num_saved_bits_);

    if (total_bits >= 8) {

      uint8_t new_byte = static_cast<uint8_t>(new_value);

      std::back_insert_iterator<std::vector<uint8_t>>::operator=(new_byte);

      total_bits -= 8;

      new_value = new_value >> 8;

    }

    num_saved_bits_ = total_bits;

    uint8_t mask = 0xff >> (8 - num_saved_bits_);

    saved_bits_ = static_cast<uint8_t>(new_value) & mask;

  }

  void insert_bits(uint8_t byte, size_t num_bits);



  void insert_byte(uint8_t byte) {

    insert_bits(byte, 8);

  }

  void insert_byte(uint8_t byte);



  bool IsByteAligned() {

    return num_saved_bits_ == 0;

  }

  bool IsByteAligned();



 private:

  size_t num_saved_bits_{0};

system/gd/packet/bit_inserter_unittest.cc

+36 −12
Original line number Diff line number Diff line
@@ -27,12 +27,6 @@ using std::vector; 
namespace bluetooth {

namespace packet {



class BitInserterTest : public ::testing::Test {

 public:

  BitInserterTest() {}

  ~BitInserterTest() = default;

};



TEST(BitInserterTest, addMoreBits) {

  std::vector<uint8_t> bytes;

  BitInserter it(bytes);
@@ -41,17 +35,47 @@ TEST(BitInserterTest, addMoreBits) { 
    it.insert_bits(static_cast<uint8_t>(i), i);

  }

  it.insert_bits(static_cast<uint8_t>(0b1010), 4);

  std::vector<uint8_t> result = {

      0b00011101 /* 3 2 1 */,

      0b00010101 /* 5 4 */,

      0b11100011 /* 7 6 */,

      0b10000000 /* 8 */,

  std::vector<uint8_t> result = {0b00011101 /* 3 2 1 */, 0b00010101 /* 5 4 */, 0b11100011 /* 7 6 */, 0b10000000 /* 8 */,

                                 0b10100000 /* filled with 1010 */};



  ASSERT_EQ(result.size(), bytes.size());

  for (size_t i = 0; i < bytes.size(); i++) {

    ASSERT_EQ(result[i], bytes[i]);

  }

}



TEST(BitInserterTest, observerTest) {

  std::vector<uint8_t> bytes;

  BitInserter it(bytes);

  std::vector<uint8_t> copy;



  uint64_t checksum = 0x0123456789abcdef;

  it.RegisterObserver(ByteObserver([&copy](uint8_t byte) { copy.push_back(byte); }, [checksum]() { return checksum; }));



  for (size_t i = 0; i < 9; i++) {

    it.insert_bits(static_cast<uint8_t>(i), i);

  }

  it.insert_bits(static_cast<uint8_t>(0b1010), 4);

  std::vector<uint8_t> result = {0b00011101 /* 3 2 1 */, 0b00010101 /* 5 4 */, 0b11100011 /* 7 6 */, 0b10000000 /* 8 */,

                                 0b10100000 /* filled with 1010 */};



  ASSERT_EQ(result.size(), bytes.size());

  for (size_t i = 0; i < bytes.size(); i++) {

    ASSERT_EQ(result[i], bytes[i]);

  }



  ASSERT_EQ(result.size(), copy.size());

  for (size_t i = 0; i < copy.size(); i++) {

    ASSERT_EQ(result[i], copy[i]);

  }



  ByteObserver observer = it.UnregisterObserver();

  ASSERT_EQ(checksum, observer.GetValue());

  uint8_t another_byte = 0xef;

  it.insert_bits(another_byte, 8);

  ASSERT_EQ(bytes.back(), another_byte);

  ASSERT_EQ(result.size() + 1, bytes.size());

  ASSERT_EQ(result.size(), copy.size());

}



}  // namespace packet

system/gd/packet/byte_inserter.cc

0 → 100644
+48 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include "packet/byte_inserter.h"



#include "os/log.h"



namespace bluetooth {

namespace packet {



ByteInserter::ByteInserter(std::vector<uint8_t>& vector) : std::back_insert_iterator<std::vector<uint8_t>>(vector) {}



ByteInserter::~ByteInserter() {

  ASSERT(registered_observers_.size() == 0);

}



void ByteInserter::RegisterObserver(ByteObserver observer) {

  registered_observers_.push_back(observer);

}



ByteObserver ByteInserter::UnregisterObserver() {

  ByteObserver observer = registered_observers_.back();

  registered_observers_.pop_back();

  return observer;

}



void ByteInserter::insert_byte(uint8_t byte) {

  for (auto& observer : registered_observers_) {

    observer.OnByte(byte);

  }

  std::back_insert_iterator<std::vector<uint8_t>>::operator=(byte);

}



}  // namespace packet

}  // namespace bluetooth