vendor_libs/test_vendor_lib/packets/link_layer/link_layer_packet_builder.cc

/*
 * Copyright 2018 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 "link_layer_packet_builder.h"
#include "link_layer_packet_view.h"

#include "base/logging.h"

using std::vector;

namespace test_vendor_lib {

namespace packets {

LinkLayerPacketBuilder::LinkLayerPacketBuilder(Link::PacketType type, const Address& source, const Address& dest)
    : type_(type), source_addr_(source), dest_addr_(dest) {}

LinkLayerPacketBuilder::LinkLayerPacketBuilder(Link::PacketType type, std::unique_ptr<PacketBuilder> packet,
                                               const Address& source)
    : type_(type), source_addr_(source), dest_addr_(Address::kEmpty), builder_(std::move(packet)) {}

LinkLayerPacketBuilder::LinkLayerPacketBuilder(Link::PacketType type, std::unique_ptr<PacketBuilder> packet,
                                               const Address& source, const Address& dest)
    : type_(type), source_addr_(source), dest_addr_(dest), builder_(std::move(packet)) {}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapAcl(std::unique_ptr<ViewForwarderBuilder> acl,
                                                                        const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::ACL, std::move(acl), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapCommand(std::unique_ptr<CommandBuilder> command,
                                                                            const Address& source,
                                                                            const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::COMMAND, std::move(command), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapDisconnect(
    std::unique_ptr<DisconnectBuilder> disconnect, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::DISCONNECT, std::move(disconnect), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapEncryptConnection(
    std::unique_ptr<EncryptConnectionBuilder> encrypt_connection, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::ENCRYPT_CONNECTION, std::move(encrypt_connection), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapEncryptConnectionResponse(
    std::unique_ptr<EncryptConnectionBuilder> encrypt_connection, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(new LinkLayerPacketBuilder(
      Link::PacketType::ENCRYPT_CONNECTION_RESPONSE, std::move(encrypt_connection), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapInquiry(std::unique_ptr<InquiryBuilder> inquiry,
                                                                            const Address& source) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::INQUIRY, std::move(inquiry), source));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapInquiryResponse(
    std::unique_ptr<InquiryResponseBuilder> inquiry_response, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::INQUIRY_RESPONSE, std::move(inquiry_response), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapIoCapabilityRequest(
    std::unique_ptr<IoCapabilityBuilder> io_capability, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::IO_CAPABILITY_REQUEST, std::move(io_capability), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapIoCapabilityResponse(
    std::unique_ptr<IoCapabilityBuilder> io_capability, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::IO_CAPABILITY_RESPONSE, std::move(io_capability), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapIoCapabilityNegativeResponse(
    std::unique_ptr<IoCapabilityNegativeResponseBuilder> io_capability_negative_response, const Address& source,
    const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(new LinkLayerPacketBuilder(
      Link::PacketType::IO_CAPABILITY_NEGATIVE_RESPONSE, std::move(io_capability_negative_response), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapLeAdvertisement(
    std::unique_ptr<LeAdvertisementBuilder> advertisement, const Address& source) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::LE_ADVERTISEMENT, std::move(advertisement), source));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapLeScan(const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(new LinkLayerPacketBuilder(Link::PacketType::LE_SCAN, source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapLeScanResponse(
    std::unique_ptr<LeAdvertisementBuilder> scan_response, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::LE_SCAN_RESPONSE, std ::move(scan_response), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapPage(std::unique_ptr<PageBuilder> page,
                                                                         const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::PAGE, std::move(page), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapPageResponse(
    std::unique_ptr<PageResponseBuilder> page_response, const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::PAGE_RESPONSE, std::move(page_response), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapResponse(std::unique_ptr<ResponseBuilder> response,
                                                                             const Address& source,
                                                                             const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::RESPONSE, std::move(response), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::WrapSco(std::unique_ptr<ViewForwarderBuilder> sco,
                                                                        const Address& source, const Address& dest) {
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(Link::PacketType::SCO, std::move(sco), source, dest));
}

std::shared_ptr<LinkLayerPacketBuilder> LinkLayerPacketBuilder::ReWrap(
    const std::shared_ptr<std::vector<uint8_t>> raw_packet) {
  LinkLayerPacketView received = LinkLayerPacketView::Create(raw_packet);
  Link::PacketType packet_type = received.GetType();
  Address source = received.GetSourceAddress();
  Address dest = received.GetDestinationAddress();
  PacketView<true> payload = received.GetPayload();
  std::unique_ptr<PacketBuilder> builder = ViewForwarderBuilder::Create(payload);
  return std::shared_ptr<LinkLayerPacketBuilder>(
      new LinkLayerPacketBuilder(packet_type, std::move(builder), source, dest));
}

size_t LinkLayerPacketBuilder::size() const {
  size_t builder_size = (builder_ ? builder_->size() : 0);
  return Link::kTypeBytes + Link::kSizeBytes + 2 * Address::kLength + builder_size;
}

void LinkLayerPacketBuilder::Serialize(std::back_insert_iterator<std::vector<uint8_t>> it) const {
  insert(static_cast<uint32_t>(size() - Link::kSizeBytes), it);
  insert(static_cast<uint8_t>(type_), it);
  insert_address(source_addr_.address, it);
  insert_address(dest_addr_.address, it);
  if (builder_) {
    builder_->Serialize(it);
  }
}

}  // namespace packets
}  // namespace test_vendor_lib