#define LOG_MODULE PacketLogModuleWakeOnLanLayer

#include "WakeOnLanLayer.h"

#include "GeneralUtils.h"

#include "Logger.h"

namespace pcpp

{

void WakeOnLanLayer::init(uint16_t len)

{

  m_Data = new uint8_t[len];

  m_DataLen = len;

  m_Protocol = WakeOnLan;

  memset(getWakeOnLanHeader()->sync, 0xFF, 6);

}

WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress &targetAddr)

{

  init(sizeof(wol_header));

  setTargetAddr(targetAddr);

}

WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress &targetAddr, uint8_t *password, uint8_t len)

{

  init(sizeof(wol_header) + len);

  setTargetAddr(targetAddr);

  setPassword(password, len);

}

WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress &targetAddr, const pcpp::MacAddress &password)

{

  init(sizeof(wol_header) + 6);

  setTargetAddr(targetAddr);

  setPassword(password);

}

WakeOnLanLayer::WakeOnLanLayer(const pcpp::MacAddress &targetAddr, const IPv4Address &password)

{

  init(sizeof(wol_header) + 4);

  setTargetAddr(targetAddr);

  setPassword(password);

}

pcpp::MacAddress WakeOnLanLayer::getTargetAddr() const

{

  return pcpp::MacAddress(getWakeOnLanHeader()->addrBody);

}

void WakeOnLanLayer::setTargetAddr(const pcpp::MacAddress &targetAddr)

{

  for (size_t idx = 0; idx < 16; ++idx)

    memcpy(&(getWakeOnLanHeader()->addrBody[idx * 6]), targetAddr.getRawData(), 6);

}

std::string WakeOnLanLayer::getPassword() const

{

  size_t passSize = m_DataLen - sizeof(wol_header);

  switch (passSize)

  {

  case 0:

    return std::string();

  case 4:

    return IPv4Address(&m_Data[sizeof(wol_header)]).toString();

  case 6:

    return MacAddress(&m_Data[sizeof(wol_header)]).toString();

  default:

    return byteArrayToHexString(&m_Data[sizeof(wol_header)], passSize);

  }

}

bool WakeOnLanLayer::setPassword(const uint8_t *password, uint8_t len)

{

  if (len)

  {

    if (m_DataLen > sizeof(wol_header) + len)

    {

      if (!shortenLayer(sizeof(wol_header), m_DataLen - (sizeof(wol_header) + len)))

      {

        PCPP_LOG_ERROR("Can't shorten Wake on LAN layer");

        return false;

      }

    }

    else if (m_DataLen < sizeof(wol_header) + len)

    {

      if (!extendLayer(m_DataLen, (sizeof(wol_header) + len) - m_DataLen))

      {

        PCPP_LOG_ERROR("Can't extend Wake on LAN layer");

        return false;

      }

    }

    memcpy(&m_Data[sizeof(wol_header)], password, len);

  }

  return true;

}

bool WakeOnLanLayer::setPassword(const std::string &password)

{

  return setPassword(reinterpret_cast<const uint8_t*>(password.c_str()), password.size());

}

bool WakeOnLanLayer::setPassword(const MacAddress &addr)

{

  return setPassword(addr.getRawData(), 6);

}

bool WakeOnLanLayer::setPassword(const IPv4Address &addr)

{

  return setPassword(addr.toBytes(), 4);

}

bool WakeOnLanLayer::isDataValid(const uint8_t *data, size_t dataSize)

{

  if (data && dataSize >= sizeof(wol_header))

  {

    // It should repeat same MAC address at the payload 16 times

    pcpp::MacAddress bufAddr(&data[6]);

    for (size_t idx = 1; idx < 16; ++idx)

    {

      if (bufAddr != pcpp::MacAddress(&data[6 + idx * 6]))

        return false;

    }

    return true;

  }

  return false;

}

std::string WakeOnLanLayer::toString() const

{

  return "Wake On LAN Layer, target address: " + getTargetAddr().toString();

}

} // namespace pcpp