#define LOG_MODULE PacketLogModuleSllLayer

#include "SllLayer.h"

#include "Logger.h"

#include "IPv4Layer.h"

#include "IPv6Layer.h"

#include "PayloadLayer.h"

#include "ArpLayer.h"

#include "VlanLayer.h"

#include "PPPoELayer.h"

#include "MplsLayer.h"

#include "EndianPortable.h"

#include "GeneralUtils.h"

namespace pcpp

{

  SllLayer::SllLayer(uint16_t packetType, uint16_t ARPHRDType)

  {

    allocData(sizeof(sll_header));

    auto* sllHdr = reinterpret_cast<sll_header*>(m_Data);

    sllHdr->packet_type = htobe16(packetType);

    sllHdr->ARPHRD_type = htobe16(ARPHRDType);

    m_Protocol = SLL;

  }

  bool SllLayer::setLinkLayerAddr(uint8_t* addr, size_t addrLength)

  {

    if (addr == nullptr || addrLength == 0 || addrLength > 8)

    {

      PCPP_LOG_ERROR("Address length is out of bounds, it must be between 1 and 8");

      return false;

    }

    sll_header* sllHdr = getSllHeader();

    memcpy(sllHdr->link_layer_addr, addr, addrLength);

    sllHdr->link_layer_addr_len = htobe16(addrLength);

    return true;

  }

  bool SllLayer::setMacAddressAsLinkLayer(MacAddress const& macAddr)

  {

    uint8_t macAddrAsArr[6];

    macAddr.copyTo(macAddrAsArr);

    return setLinkLayerAddr(macAddrAsArr, 6);

  }

  void SllLayer::parseNextLayer()

  {

    if (m_DataLen <= sizeof(sll_header))

      return;

    uint8_t* payload = m_Data + sizeof(sll_header);

    size_t payloadLen = m_DataLen - sizeof(sll_header);

    sll_header* hdr = getSllHeader();

    switch (be16toh(hdr->protocol_type))

    {

    case PCPP_ETHERTYPE_IP:

    {

      tryConstructNextLayerWithFallback<IPv4Layer, PayloadLayer>(payload, payloadLen);

      break;

    }

    case PCPP_ETHERTYPE_IPV6:

    {

      tryConstructNextLayerWithFallback<IPv6Layer, PayloadLayer>(payload, payloadLen);

      break;

    }

    case PCPP_ETHERTYPE_ARP:

    {

      tryConstructNextLayerWithFallback<ArpLayer, PayloadLayer>(payload, payloadLen);

      break;

    }

    case PCPP_ETHERTYPE_VLAN:

    case PCPP_ETHERTYPE_IEEE_802_1AD:

    {

      tryConstructNextLayerWithFallback<VlanLayer, PayloadLayer>(payload, payloadLen);

      break;

    }

    case PCPP_ETHERTYPE_PPPOES:

    {

      tryConstructNextLayerWithFallback<PPPoESessionLayer, PayloadLayer>(payload, payloadLen);

      break;

    }

    case PCPP_ETHERTYPE_PPPOED:

    {

      tryConstructNextLayerWithFallback<PPPoEDiscoveryLayer, PayloadLayer>(payload, payloadLen);

      break;

    }

    case PCPP_ETHERTYPE_MPLS:

    {

      tryConstructNextLayerWithFallback<MplsLayer, PayloadLayer>(payload, payloadLen);

      break;

    }

    default:

    {

      constructNextLayer<PayloadLayer>(payload, payloadLen);

      break;

    }

    }

  }

  void SllLayer::computeCalculateFields()

  {

    if (m_NextLayer == nullptr)

      return;

    sll_header* hdr = getSllHeader();

    switch (m_NextLayer->getProtocol())

    {

    case IPv4:

      hdr->protocol_type = htobe16(PCPP_ETHERTYPE_IP);

      break;

    case IPv6:

      hdr->protocol_type = htobe16(PCPP_ETHERTYPE_IPV6);

      break;

    case ARP:

      hdr->protocol_type = htobe16(PCPP_ETHERTYPE_ARP);

      break;

    case VLAN:

      hdr->protocol_type = htobe16(PCPP_ETHERTYPE_VLAN);

      break;

    default:

      return;

    }

  }

  std::string SllLayer::toString() const

  {

    return "Linux cooked header";

  }

  const FieldDescriptor SllLayer::SerializedFields::PacketType{ Layer::SerializedFields::MaxID + 1, "packetType" };

  const FieldDescriptor SllLayer::SerializedFields::ArpHeaderType{ Layer::SerializedFields::MaxID + 2,

                                                                 "arpHeaderType" };

  const FieldDescriptor SllLayer::SerializedFields::ProtocolType{ Layer::SerializedFields::MaxID + 3,

                                                                "protocolType" };

  const FieldDescriptor SllLayer::SerializedFields::LinkLayerAddress{ Layer::SerializedFields::MaxID + 4,

                                                                    "linkLayerAddress" };

  void SllLayer::serializeLayer(ObjectScope& serializer) const

  {

    auto* header = getSllHeader();

    serializer.writeField(SerializedFields::PacketType, be16toh(header->packet_type));

    serializer.writeField(SerializedFields::ArpHeaderType, be16toh(header->ARPHRD_type));

    serializer.writeField(SerializedFields::ProtocolType, be16toh(header->protocol_type));

    auto linkLayerAddrLen = (std::min)(be16toh(header->link_layer_addr_len), static_cast<uint16_t>(8));

    serializer.writeField(SerializedFields::LinkLayerAddress,

                          byteArrayToHexString(header->link_layer_addr, linkLayerAddrLen));

  }

}  // namespace pcpp