/*
 * Copyright (c) 2007 Emmanuelle Laprise, INRIA
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 * Authors: Emmanuelle Laprise <emmanuelle.laprise@bluekazoo.ca>
 *          Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */

#include "packet-socket.h"

#include "packet-socket-address.h"

#include "ns3/log.h"
#include "ns3/node.h"
#include "ns3/packet.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/uinteger.h"

#include <algorithm>

namespace ns3
{

NS_LOG_COMPONENT_DEFINE("PacketSocket");

NS_OBJECT_ENSURE_REGISTERED(PacketSocket);

TypeId
PacketSocket::GetTypeId()
{
    static TypeId tid = TypeId("ns3::PacketSocket")
                            .SetParent<Socket>()
                            .SetGroupName("Network")
                            .AddConstructor<PacketSocket>()
                            .AddTraceSource("Drop",
                                            "Drop packet due to receive buffer overflow",
                                            MakeTraceSourceAccessor(&PacketSocket::m_dropTrace),
                                            "ns3::Packet::TracedCallback")
                            .AddAttribute("RcvBufSize",
                                          "PacketSocket maximum receive buffer size (bytes)",
                                          UintegerValue(131072),
                                          MakeUintegerAccessor(&PacketSocket::m_rcvBufSize),
                                          MakeUintegerChecker<uint32_t>());
    return tid;
}

PacketSocket::PacketSocket()
    : m_rxAvailable(0)
{
    NS_LOG_FUNCTION(this);
    m_state = STATE_OPEN;
    m_shutdownSend = false;
    m_shutdownRecv = false;
    m_errno = ERROR_NOTERROR;
    m_isSingleDevice = false;
    m_device = 0;
}

void
PacketSocket::SetNode(Ptr<Node> node)
{
    NS_LOG_FUNCTION(this << node);
    m_node = node;
}

PacketSocket::~PacketSocket()
{
    NS_LOG_FUNCTION(this);
}

void
PacketSocket::DoDispose()
{
    NS_LOG_FUNCTION(this);
    m_device = 0;
}

Socket::SocketErrno
PacketSocket::GetErrno() const
{
    NS_LOG_FUNCTION(this);
    return m_errno;
}

Socket::SocketType
PacketSocket::GetSocketType() const
{
    NS_LOG_FUNCTION(this);
    return NS3_SOCK_RAW;
}

Ptr<Node>
PacketSocket::GetNode() const
{
    NS_LOG_FUNCTION(this);
    return m_node;
}

int
PacketSocket::Bind()
{
    NS_LOG_FUNCTION(this);
    PacketSocketAddress address;
    address.SetProtocol(0);
    address.SetAllDevices();
    return DoBind(address);
}

int
PacketSocket::Bind6()
{
    NS_LOG_FUNCTION(this);
    return Bind();
}

int
PacketSocket::Bind(const Address& address)
{
    NS_LOG_FUNCTION(this << address);
    if (!PacketSocketAddress::IsMatchingType(address))
    {
        m_errno = ERROR_INVAL;
        return -1;
    }
    PacketSocketAddress ad = PacketSocketAddress::ConvertFrom(address);
    return DoBind(ad);
}

int
PacketSocket::DoBind(const PacketSocketAddress& address)
{
    NS_LOG_FUNCTION(this << address);
    if (m_state == STATE_BOUND || m_state == STATE_CONNECTED)
    {
        m_errno = ERROR_INVAL;
        return -1;
    }
    if (m_state == STATE_CLOSED)
    {
        m_errno = ERROR_BADF;
        return -1;
    }
    Ptr<NetDevice> dev;
    if (address.IsSingleDevice())
    {
        dev = m_node->GetDevice(address.GetSingleDevice());
    }
    else
    {
        dev = nullptr;
    }
    m_node->RegisterProtocolHandler(MakeCallback(&PacketSocket::ForwardUp, this),
                                    address.GetProtocol(),
                                    dev);
    m_state = STATE_BOUND;
    m_protocol = address.GetProtocol();
    m_isSingleDevice = address.IsSingleDevice();
    m_device = address.GetSingleDevice();
    m_boundnetdevice = dev;
    return 0;
}

int
PacketSocket::ShutdownSend()
{
    NS_LOG_FUNCTION(this);
    if (m_state == STATE_CLOSED)
    {
        m_errno = ERROR_BADF;
        return -1;
    }
    m_shutdownSend = true;
    return 0;
}

int
PacketSocket::ShutdownRecv()
{
    NS_LOG_FUNCTION(this);
    if (m_state == STATE_CLOSED)
    {
        m_errno = ERROR_BADF;
        return -1;
    }
    m_shutdownRecv = true;
    return 0;
}

int
PacketSocket::Close()
{
    NS_LOG_FUNCTION(this);
    if (m_state == STATE_CLOSED)
    {
        m_errno = ERROR_BADF;
        return -1;
    }
    else if (m_state == STATE_BOUND || m_state == STATE_CONNECTED)
    {
        m_node->UnregisterProtocolHandler(MakeCallback(&PacketSocket::ForwardUp, this));
    }
    m_state = STATE_CLOSED;
    m_shutdownSend = true;
    m_shutdownRecv = true;
    return 0;
}

int
PacketSocket::Connect(const Address& ad)
{
    NS_LOG_FUNCTION(this << ad);

    if (m_state == STATE_CLOSED)
    {
        m_errno = ERROR_BADF;
        goto error;
    }
    if (m_state == STATE_OPEN)
    {
        // connect should happen _after_ bind.
        m_errno = ERROR_INVAL; // generic error condition.
        goto error;
    }
    if (m_state == STATE_CONNECTED)
    {
        m_errno = ERROR_ISCONN;
        goto error;
    }
    if (!PacketSocketAddress::IsMatchingType(ad))
    {
        m_errno = ERROR_AFNOSUPPORT;
        goto error;
    }
    m_destAddr = ad;
    m_state = STATE_CONNECTED;
    NotifyConnectionSucceeded();
    return 0;
error:
    NotifyConnectionFailed();
    return -1;
}

int
PacketSocket::Listen()
{
    NS_LOG_FUNCTION(this);
    m_errno = Socket::ERROR_OPNOTSUPP;
    return -1;
}

int
PacketSocket::Send(Ptr<Packet> p, uint32_t flags)
{
    NS_LOG_FUNCTION(this << p << flags);
    if (m_state == STATE_OPEN || m_state == STATE_BOUND)
    {
        m_errno = ERROR_NOTCONN;
        return -1;
    }
    return SendTo(p, flags, m_destAddr);
}

uint32_t
PacketSocket::GetMinMtu(PacketSocketAddress ad) const
{
    NS_LOG_FUNCTION(this << ad);
    if (ad.IsSingleDevice())
    {
        Ptr<NetDevice> device = m_node->GetDevice(ad.GetSingleDevice());
        return device->GetMtu();
    }
    else
    {
        uint32_t minMtu = 0xffff;
        for (uint32_t i = 0; i < m_node->GetNDevices(); i++)
        {
            Ptr<NetDevice> device = m_node->GetDevice(i);
            minMtu = std::min(minMtu, (uint32_t)device->GetMtu());
        }
        return minMtu;
    }
}

uint32_t
PacketSocket::GetTxAvailable() const
{
    NS_LOG_FUNCTION(this);
    if (m_state == STATE_CONNECTED)
    {
        PacketSocketAddress ad = PacketSocketAddress::ConvertFrom(m_destAddr);
        return GetMinMtu(ad);
    }
    // If we are not connected, we return a 'safe' value by default.
    return 0xffff;
}

int
PacketSocket::SendTo(Ptr<Packet> p, uint32_t flags, const Address& address)
{
    NS_LOG_FUNCTION(this << p << flags << address);
    PacketSocketAddress ad;
    if (m_state == STATE_CLOSED)
    {
        NS_LOG_LOGIC("ERROR_BADF");
        m_errno = ERROR_BADF;
        return -1;
    }
    if (m_shutdownSend)
    {
        NS_LOG_LOGIC("ERROR_SHUTDOWN");
        m_errno = ERROR_SHUTDOWN;
        return -1;
    }
    if (!PacketSocketAddress::IsMatchingType(address))
    {
        NS_LOG_LOGIC("ERROR_AFNOSUPPORT");
        m_errno = ERROR_AFNOSUPPORT;
        return -1;
    }
    ad = PacketSocketAddress::ConvertFrom(address);
    if (p->GetSize() > GetMinMtu(ad))
    {
        m_errno = ERROR_MSGSIZE;
        return -1;
    }

    uint8_t priority = GetPriority();
    if (priority)
    {
        SocketPriorityTag priorityTag;
        priorityTag.SetPriority(priority);
        p->ReplacePacketTag(priorityTag);
    }

    bool error = false;
    Address dest = ad.GetPhysicalAddress();
    uint32_t pktSize = p->GetSize(); // device->Send() may modify the packet
    if (ad.IsSingleDevice())
    {
        Ptr<NetDevice> device = m_node->GetDevice(ad.GetSingleDevice());
        if (!device->Send(p, dest, ad.GetProtocol()))
        {
            NS_LOG_LOGIC("error: NetDevice::Send error");
            error = true;
        }
    }
    else
    {
        for (uint32_t i = 0; i < m_node->GetNDevices(); i++)
        {
            Ptr<NetDevice> device = m_node->GetDevice(i);
            if (!device->Send(p, dest, ad.GetProtocol()))
            {
                NS_LOG_LOGIC("error: NetDevice::Send error");
                error = true;
            }
        }
    }
    if (!error)
    {
        NotifyDataSent(pktSize);
        NotifySend(GetTxAvailable());
    }

    if (error)
    {
        NS_LOG_LOGIC("ERROR_INVAL 2");
        m_errno = ERROR_INVAL;
        return -1;
    }
    else
    {
        return pktSize;
    }
}

void
PacketSocket::ForwardUp(Ptr<NetDevice> device,
                        Ptr<const Packet> packet,
                        uint16_t protocol,
                        const Address& from,
                        const Address& to,
                        NetDevice::PacketType packetType)
{
    NS_LOG_FUNCTION(this << device << packet << protocol << from << to << packetType);
    if (m_shutdownRecv)
    {
        return;
    }
    PacketSocketAddress address;
    address.SetPhysicalAddress(from);
    address.SetSingleDevice(device->GetIfIndex());
    address.SetProtocol(protocol);

    if ((m_rxAvailable + packet->GetSize()) <= m_rcvBufSize)
    {
        Ptr<Packet> copy = packet->Copy();
        DeviceNameTag dnt;
        dnt.SetDeviceName(NetDevice::GetTypeId().GetName());
        PacketSocketTag pst;
        pst.SetPacketType(packetType);
        pst.SetDestAddress(to);
        copy->AddPacketTag(pst); // Attach Packet Type and Dest Address
        copy->AddPacketTag(dnt); // Attach device source name
        // in case the packet still has a priority tag, remove it
        SocketPriorityTag priorityTag;
        copy->RemovePacketTag(priorityTag);
        m_deliveryQueue.emplace(copy, address);
        m_rxAvailable += packet->GetSize();
        NS_LOG_LOGIC("UID is " << packet->GetUid() << " PacketSocket " << this);
        NotifyDataRecv();
    }
    else
    {
        // In general, this case should not occur unless the
        // receiving application reads data from this socket slowly
        // in comparison to the arrival rate
        //
        // drop and trace packet
        NS_LOG_WARN("No receive buffer space available.  Drop.");
        m_dropTrace(packet);
    }
}

uint32_t
PacketSocket::GetRxAvailable() const
{
    NS_LOG_FUNCTION(this);
    // We separately maintain this state to avoid walking the queue
    // every time this might be called
    return m_rxAvailable;
}

Ptr<Packet>
PacketSocket::Recv(uint32_t maxSize, uint32_t flags)
{
    NS_LOG_FUNCTION(this << maxSize << flags);

    Address fromAddress;
    Ptr<Packet> packet = RecvFrom(maxSize, flags, fromAddress);
    return packet;
}

Ptr<Packet>
PacketSocket::RecvFrom(uint32_t maxSize, uint32_t flags, Address& fromAddress)
{
    NS_LOG_FUNCTION(this << maxSize << flags);

    if (m_deliveryQueue.empty())
    {
        return nullptr;
    }
    Ptr<Packet> p = m_deliveryQueue.front().first;
    fromAddress = m_deliveryQueue.front().second;

    if (p->GetSize() <= maxSize)
    {
        m_deliveryQueue.pop();
        m_rxAvailable -= p->GetSize();
    }
    else
    {
        p = nullptr;
    }
    return p;
}

int
PacketSocket::GetSockName(Address& address) const
{
    NS_LOG_FUNCTION(this << address);
    PacketSocketAddress ad;

    ad.SetProtocol(m_protocol);
    if (m_isSingleDevice)
    {
        Ptr<NetDevice> device = m_node->GetDevice(m_device);
        ad.SetPhysicalAddress(device->GetAddress());
        ad.SetSingleDevice(m_device);
    }
    else
    {
        ad.SetPhysicalAddress(Address());
        ad.SetAllDevices();
    }
    address = ad;

    return 0;
}

int
PacketSocket::GetPeerName(Address& address) const
{
    NS_LOG_FUNCTION(this << address);

    if (m_state != STATE_CONNECTED)
    {
        m_errno = ERROR_NOTCONN;
        return -1;
    }

    address = m_destAddr;

    return 0;
}

bool
PacketSocket::SetAllowBroadcast(bool allowBroadcast)
{
    NS_LOG_FUNCTION(this << allowBroadcast);
    return !allowBroadcast;
}

bool
PacketSocket::GetAllowBroadcast() const
{
    NS_LOG_FUNCTION(this);
    return false;
}

/***************************************************************
 *           PacketSocket Tags
 ***************************************************************/

PacketSocketTag::PacketSocketTag()
{
}

void
PacketSocketTag::SetPacketType(NetDevice::PacketType t)
{
    m_packetType = t;
}

NetDevice::PacketType
PacketSocketTag::GetPacketType() const
{
    return m_packetType;
}

void
PacketSocketTag::SetDestAddress(Address a)
{
    m_destAddr = a;
}

Address
PacketSocketTag::GetDestAddress() const
{
    return m_destAddr;
}

NS_OBJECT_ENSURE_REGISTERED(PacketSocketTag);

TypeId
PacketSocketTag::GetTypeId()
{
    static TypeId tid = TypeId("ns3::PacketSocketTag")
                            .SetParent<Tag>()
                            .SetGroupName("Network")
                            .AddConstructor<PacketSocketTag>();
    return tid;
}

TypeId
PacketSocketTag::GetInstanceTypeId() const
{
    return GetTypeId();
}

uint32_t
PacketSocketTag::GetSerializedSize() const
{
    return 1 + m_destAddr.GetSerializedSize();
}

void
PacketSocketTag::Serialize(TagBuffer i) const
{
    i.WriteU8(m_packetType);
    m_destAddr.Serialize(i);
}

void
PacketSocketTag::Deserialize(TagBuffer i)
{
    m_packetType = (NetDevice::PacketType)i.ReadU8();
    m_destAddr.Deserialize(i);
}

void
PacketSocketTag::Print(std::ostream& os) const
{
    os << "packetType=" << m_packetType;
}

/***************************************************************
 *           DeviceName Tags
 ***************************************************************/

DeviceNameTag::DeviceNameTag()
{
}

void
DeviceNameTag::SetDeviceName(std::string n)
{
    if (n.substr(0, 5) == "ns3::")
    {
        n = n.substr(5);
    }
    m_deviceName = n;
}

std::string
DeviceNameTag::GetDeviceName() const
{
    return m_deviceName;
}

NS_OBJECT_ENSURE_REGISTERED(DeviceNameTag);

TypeId
DeviceNameTag::GetTypeId()
{
    static TypeId tid = TypeId("ns3::DeviceNameTag")
                            .SetParent<Tag>()
                            .SetGroupName("Network")
                            .AddConstructor<DeviceNameTag>();
    return tid;
}

TypeId
DeviceNameTag::GetInstanceTypeId() const
{
    return GetTypeId();
}

uint32_t
DeviceNameTag::GetSerializedSize() const
{
    uint32_t s = 1 + m_deviceName.size(); // +1 for name length field
    return s;
}

void
DeviceNameTag::Serialize(TagBuffer i) const
{
    const char* n = m_deviceName.c_str();
    auto l = (uint8_t)m_deviceName.size();

    i.WriteU8(l);
    i.Write((uint8_t*)n, (uint32_t)l);
}

void
DeviceNameTag::Deserialize(TagBuffer i)
{
    uint8_t l = i.ReadU8();
    char buf[256];

    i.Read((uint8_t*)buf, (uint32_t)l);
    m_deviceName = std::string(buf, l);
}

void
DeviceNameTag::Print(std::ostream& os) const
{
    os << "DeviceName=" << m_deviceName;
}

} // namespace ns3