/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2007 INRIA

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#include "ns3/log.h"

#include "ns3/node.h"

#include "ns3/inet-socket-address.h"

#include "ns3/inet6-socket-address.h"

#include "ns3/ipv4-route.h"

#include "ns3/ipv6-route.h"

#include "ns3/ipv4.h"

#include "ns3/ipv6.h"

#include "ns3/ipv4-header.h"

#include "ns3/ipv4-routing-protocol.h"

#include "ns3/ipv6-routing-protocol.h"

#include "ns3/udp-socket-factory.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/ipv4-packet-info-tag.h"

#include "udp-socket-impl.h"

#include "udp-l4-protocol.h"

#include "ipv4-end-point.h"

#include "ipv6-end-point.h"

#include <limits>

NS_LOG_COMPONENT_DEFINE ("UdpSocketImpl");

namespace ns3 {

static const uint32_t MAX_IPV4_UDP_DATAGRAM_SIZE = 65507;

// Add attributes generic to all UdpSockets to base class UdpSocket

TypeId

UdpSocketImpl::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::UdpSocketImpl")

    .SetParent<UdpSocket> ()

    .AddConstructor<UdpSocketImpl> ()

    .AddTraceSource ("Drop", "Drop UDP packet due to receive buffer overflow",

                     MakeTraceSourceAccessor (&UdpSocketImpl::m_dropTrace))

    .AddAttribute ("IcmpCallback", "Callback invoked whenever an icmp error is received on this socket.",

                   CallbackValue (),

                   MakeCallbackAccessor (&UdpSocketImpl::m_icmpCallback),

                   MakeCallbackChecker ())

    .AddAttribute ("IcmpCallback6", "Callback invoked whenever an icmpv6 error is received on this socket.",

                   CallbackValue (),

                   MakeCallbackAccessor (&UdpSocketImpl::m_icmpCallback6),

                   MakeCallbackChecker ())

  ;

  return tid;

}

UdpSocketImpl::UdpSocketImpl ()

  : m_endPoint (0),

    m_endPoint6 (0),

    m_node (0),

    m_udp (0),

    m_errno (ERROR_NOTERROR),

    m_shutdownSend (false),

    m_shutdownRecv (false),

    m_connected (false),

    m_rxAvailable (0)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_allowBroadcast = false;

}

UdpSocketImpl::~UdpSocketImpl ()

{

  NS_LOG_FUNCTION_NOARGS ();

  // XXX todo:  leave any multicast groups that have been joined

  m_node = 0;

  /**

   * Note: actually this function is called AFTER

   * UdpSocketImpl::Destroy or UdpSocketImpl::Destroy6

   * so the code below is unnecessary in normal operations

   */

  if (m_endPoint != 0)

    {

      NS_ASSERT (m_udp != 0);

      /**

       * Note that this piece of code is a bit tricky:

       * when DeAllocate is called, it will call into

       * Ipv4EndPointDemux::Deallocate which triggers

       * a delete of the associated endPoint which triggers

       * in turn a call to the method UdpSocketImpl::Destroy below

       * will will zero the m_endPoint field.

       */

      NS_ASSERT (m_endPoint != 0);

      m_udp->DeAllocate (m_endPoint);

      NS_ASSERT (m_endPoint == 0);

    }

  if (m_endPoint6 != 0)

    {

      NS_ASSERT (m_udp != 0);

      /**

       * Note that this piece of code is a bit tricky:

       * when DeAllocate is called, it will call into

       * Ipv4EndPointDemux::Deallocate which triggers

       * a delete of the associated endPoint which triggers

       * in turn a call to the method UdpSocketImpl::Destroy below

       * will will zero the m_endPoint field.

       */

      NS_ASSERT (m_endPoint6 != 0);

      m_udp->DeAllocate (m_endPoint6);

      NS_ASSERT (m_endPoint6 == 0);

    }

  m_udp = 0;

}

void 

UdpSocketImpl::SetNode (Ptr<Node> node)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_node = node;

}

void 

UdpSocketImpl::SetUdp (Ptr<UdpL4Protocol> udp)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_udp = udp;

}

enum Socket::SocketErrno

UdpSocketImpl::GetErrno (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_errno;

}

enum Socket::SocketType

UdpSocketImpl::GetSocketType (void) const

{

  return NS3_SOCK_DGRAM;

}

Ptr<Node>

UdpSocketImpl::GetNode (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

void 

UdpSocketImpl::Destroy (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_endPoint = 0;

}

void

UdpSocketImpl::Destroy6 (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_endPoint6 = 0;

}

int

UdpSocketImpl::FinishBind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  bool done = false;

  if (m_endPoint != 0)

    {

      m_endPoint->SetRxCallback (MakeCallback (&UdpSocketImpl::ForwardUp, Ptr<UdpSocketImpl> (this)));

      m_endPoint->SetIcmpCallback (MakeCallback (&UdpSocketImpl::ForwardIcmp, Ptr<UdpSocketImpl> (this)));

      m_endPoint->SetDestroyCallback (MakeCallback (&UdpSocketImpl::Destroy, Ptr<UdpSocketImpl> (this)));

      done = true;

    }

  if (m_endPoint6 != 0)

    {

      m_endPoint6->SetRxCallback (MakeCallback (&UdpSocketImpl::ForwardUp6, Ptr<UdpSocketImpl> (this)));

      m_endPoint6->SetIcmpCallback (MakeCallback (&UdpSocketImpl::ForwardIcmp6, Ptr<UdpSocketImpl> (this)));

      m_endPoint6->SetDestroyCallback (MakeCallback (&UdpSocketImpl::Destroy6, Ptr<UdpSocketImpl> (this)));

      done = true;

    }

  if (done)

    {

      return 0;

    }

  return -1;

}

int

UdpSocketImpl::Bind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_endPoint = m_udp->Allocate ();

  return FinishBind ();

}

int

UdpSocketImpl::Bind6 (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_endPoint6 = m_udp->Allocate6 ();

  return FinishBind ();

}

int 

UdpSocketImpl::Bind (const Address &address)

{

  NS_LOG_FUNCTION (this << address);

  if (InetSocketAddress::IsMatchingType (address))

    {

      InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

      Ipv4Address ipv4 = transport.GetIpv4 ();

      uint16_t port = transport.GetPort ();

      if (ipv4 == Ipv4Address::GetAny () && port == 0)

        {

          m_endPoint = m_udp->Allocate ();

        }

      else if (ipv4 == Ipv4Address::GetAny () && port != 0)

        {

          m_endPoint = m_udp->Allocate (port);

        }

      else if (ipv4 != Ipv4Address::GetAny () && port == 0)

        {

          m_endPoint = m_udp->Allocate (ipv4);

        }

      else if (ipv4 != Ipv4Address::GetAny () && port != 0)

        {

          m_endPoint = m_udp->Allocate (ipv4, port);

        }

    }

  else if (Inet6SocketAddress::IsMatchingType (address))

    {

      Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);

      Ipv6Address ipv6 = transport.GetIpv6 ();

      uint16_t port = transport.GetPort ();

      if (ipv6 == Ipv6Address::GetAny () && port == 0)

        {

          m_endPoint6 = m_udp->Allocate6 ();

        }

      else if (ipv6 == Ipv6Address::GetAny () && port != 0)

        {

          m_endPoint6 = m_udp->Allocate6 (port);

        }

      else if (ipv6 != Ipv6Address::GetAny () && port == 0)

        {

          m_endPoint6 = m_udp->Allocate6 (ipv6);

        }

      else if (ipv6 != Ipv6Address::GetAny () && port != 0)

        {

          m_endPoint6 = m_udp->Allocate6 (ipv6, port);

        }

    }

  else

    {

      NS_LOG_ERROR ("Not IsMatchingType");

      m_errno = ERROR_INVAL;

      return -1;

    }

  return FinishBind ();

}

int 

UdpSocketImpl::ShutdownSend (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_shutdownSend = true;

  return 0;

}

int 

UdpSocketImpl::ShutdownRecv (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_shutdownRecv = true;

  return 0;

}

int

UdpSocketImpl::Close (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_shutdownRecv == true && m_shutdownSend == true)

    {

      m_errno = Socket::ERROR_BADF;

      return -1;

    }

  m_shutdownRecv = true;

  m_shutdownSend = true;

  return 0;

}

int

UdpSocketImpl::Connect (const Address & address)

{

  NS_LOG_FUNCTION (this << address);

  if (InetSocketAddress::IsMatchingType(address) == true)

    {

      InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

      m_defaultAddress = Address(transport.GetIpv4 ());

      m_defaultPort = transport.GetPort ();

      m_connected = true;

      NotifyConnectionSucceeded ();

    }

  else if (Inet6SocketAddress::IsMatchingType(address) == true)

    {

      Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);

      m_defaultAddress = Address(transport.GetIpv6 ());

      m_defaultPort = transport.GetPort ();

      m_connected = true;

      NotifyConnectionSucceeded ();

    }

  else

    {

      return -1;

    }

  return 0;

}

int 

UdpSocketImpl::Listen (void)

{

  m_errno = Socket::ERROR_OPNOTSUPP;

  return -1;

}

int 

UdpSocketImpl::Send (Ptr<Packet> p, uint32_t flags)

{

  NS_LOG_FUNCTION (this << p << flags);

  if (!m_connected)

    {

      m_errno = ERROR_NOTCONN;

      return -1;

    }

  return DoSend (p);

}

int 

UdpSocketImpl::DoSend (Ptr<Packet> p)

{

  NS_LOG_FUNCTION (this << p);

  if ((m_endPoint == 0) && (InetSocketAddress::IsMatchingType(m_defaultAddress) == true))

    {

      if (Bind () == -1)

        {

          NS_ASSERT (m_endPoint == 0);

          return -1;

        }

      NS_ASSERT (m_endPoint != 0);

    }

  else if ((m_endPoint6 == 0) && (Inet6SocketAddress::IsMatchingType(m_defaultAddress) == true))

    {

      if (Bind6 () == -1)

        {

          NS_ASSERT (m_endPoint6 == 0);

          return -1;

        }

      NS_ASSERT (m_endPoint6 != 0);

    }

  if (m_shutdownSend)

    {

      m_errno = ERROR_SHUTDOWN;

      return -1;

    } 

  return DoSendTo (p, (const Address)m_defaultAddress);

}

int

UdpSocketImpl::DoSendTo (Ptr<Packet> p, const Address &address)

{

  NS_LOG_FUNCTION (this << p << address);

  if (!m_connected)

    {

      NS_LOG_LOGIC ("Not connected");

      if (InetSocketAddress::IsMatchingType(address) == true)

        {

          InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

          Ipv4Address ipv4 = transport.GetIpv4 ();

          uint16_t port = transport.GetPort ();

          return DoSendTo (p, ipv4, port);

        }

      else if (Inet6SocketAddress::IsMatchingType(address) == true)

        {

          Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);

          Ipv6Address ipv6 = transport.GetIpv6 ();

          uint16_t port = transport.GetPort ();

          return DoSendTo (p, ipv6, port);

        }

      else

        {

          return -1;

        }

    }

  else

    {

      // connected UDP socket must use default addresses

      NS_LOG_LOGIC ("Connected");

      if (Ipv4Address::IsMatchingType(m_defaultAddress))

        {

          return DoSendTo (p, Ipv4Address::ConvertFrom(m_defaultAddress), m_defaultPort);

        }

      else if (Ipv6Address::IsMatchingType(m_defaultAddress))

        {

          return DoSendTo (p, Ipv6Address::ConvertFrom(m_defaultAddress), m_defaultPort);

        }

    }

  m_errno = ERROR_AFNOSUPPORT;

  return(-1);

}

int

UdpSocketImpl::DoSendTo (Ptr<Packet> p, Ipv4Address dest, uint16_t port)

{

  NS_LOG_FUNCTION (this << p << dest << port);

  if (m_boundnetdevice)

    {

      NS_LOG_LOGIC ("Bound interface number " << m_boundnetdevice->GetIfIndex ());

    }

  if (m_endPoint == 0)

    {

      if (Bind () == -1)

        {

          NS_ASSERT (m_endPoint == 0);

          return -1;

        }

      NS_ASSERT (m_endPoint != 0);

    }

  if (m_shutdownSend)

    {

      m_errno = ERROR_SHUTDOWN;

      return -1;

    }

  if (p->GetSize () > GetTxAvailable () )

    {

      m_errno = ERROR_MSGSIZE;

      return -1;

    }

  Ptr<Ipv4> ipv4 = m_node->GetObject<Ipv4> ();

  // Locally override the IP TTL for this socket

  // We cannot directly modify the TTL at this stage, so we set a Packet tag

  // The destination can be either multicast, unicast/anycast, or

  // either all-hosts broadcast or limited (subnet-directed) broadcast.

  // For the latter two broadcast types, the TTL will later be set to one

  // irrespective of what is set in these socket options.  So, this tagging

  // may end up setting the TTL of a limited broadcast packet to be

  // the same as a unicast, but it will be fixed further down the stack

  if (m_ipMulticastTtl != 0 && dest.IsMulticast ())

    {

      SocketIpTtlTag tag;

      tag.SetTtl (m_ipMulticastTtl);

      p->AddPacketTag (tag);

    }

  else if (m_ipTtl != 0 && !dest.IsMulticast () && !dest.IsBroadcast ())

    {

      SocketIpTtlTag tag;

      tag.SetTtl (m_ipTtl);

      p->AddPacketTag (tag);

    }

  {

    SocketSetDontFragmentTag tag;

    bool found = p->RemovePacketTag (tag);

    if (!found)

      {

        if (m_mtuDiscover)