/* -*-  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/ipv4-route.h"

#include "ns3/ipv4.h"

#include "ns3/ipv4-header.h"

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

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

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

#include "udp-socket-impl.h"

#include "udp-l4-protocol.h"

#include "ipv4-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 ())

    ;

  return tid;

}

UdpSocketImpl::UdpSocketImpl ()

  : m_endPoint (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 ();

}

UdpSocketImpl::~UdpSocketImpl ()

{

  NS_LOG_FUNCTION_NOARGS ();

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

  m_node = 0;

  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 ::Destroy below

       * will will zero the m_endPoint field.

       */

      NS_ASSERT (m_endPoint != 0);

      m_udp->DeAllocate (m_endPoint);

      NS_ASSERT (m_endPoint == 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;

}

Ptr<Node>

UdpSocketImpl::GetNode (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

void 

UdpSocketImpl::Destroy (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_node = 0;

  m_endPoint = 0;

  m_udp = 0;

}

int

UdpSocketImpl::FinishBind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  if (m_endPoint == 0)

    {

      return -1;

    }

  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)));

  return 0;

}

int

UdpSocketImpl::Bind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_endPoint = m_udp->Allocate ();

  return FinishBind ();

}

int 

UdpSocketImpl::Bind (const Address &address)

{

  NS_LOG_FUNCTION (this << address);

  if (!InetSocketAddress::IsMatchingType (address))

    {

      NS_LOG_ERROR ("Not IsMatchingType");

      m_errno = ERROR_INVAL;

      return -1;

    }

  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);

    }

  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 = false;

  return 0;

}

int

UdpSocketImpl::Close(void)

{

  NS_LOG_FUNCTION_NOARGS ();

  return 0;

}

int

UdpSocketImpl::Connect(const Address & address)

{

  NS_LOG_FUNCTION (this << address);

  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

  m_defaultAddress = transport.GetIpv4 ();

  m_defaultPort = transport.GetPort ();

  NotifyConnectionSucceeded ();

  m_connected = true;

  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)

    {

      if (Bind () == -1)

       {

          NS_ASSERT (m_endPoint == 0);

         return -1;

       }

      NS_ASSERT (m_endPoint != 0);

    }

  if (m_shutdownSend)

    {

      m_errno = ERROR_SHUTDOWN;

      return -1;

    } 

  return DoSendTo (p, m_defaultAddress, m_defaultPort);

}

int

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

{

  NS_LOG_FUNCTION (this << p << address);

  if (!m_connected)

    {

      NS_LOG_LOGIC ("Not connected");

      InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

      Ipv4Address ipv4 = transport.GetIpv4 ();

      uint16_t port = transport.GetPort ();

      return DoSendTo (p, ipv4, port);

    }

  else

    {

      // connected UDP socket must use default addresses

      NS_LOG_LOGIC ("Connected");

      return DoSendTo (p, m_defaultAddress, m_defaultPort);

    }

}

int

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

{

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

  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);

    }

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

    {

      SocketIpTtlTag tag;

      tag.SetTtl (m_ipTtl);

    }

  {

    SocketSetDontFragmentTag tag;

    if (!found)

      {

        if (m_mtuDiscover)

          {

            tag.Enable ();

          }

        else

          {

            tag.Disable ();

          }

      }

  }

  //

  // If dest is set to the limited broadcast address (all ones),

  // convert it to send a copy of the packet out of every 

  // interface as a subnet-directed broadcast.

  // Exception:  if the interface has a /32 address, there is no

  // valid subnet-directed broadcast, so send it as limited broadcast

  // Note also that some systems will only send limited broadcast packets

  // out of the "default" interface; here we send it out all interfaces

  //

  if (dest.IsBroadcast ())

    {

      NS_LOG_LOGIC ("Limited broadcast start.");

      for (uint32_t i = 0; i < ipv4->GetNInterfaces (); i++ )

        {

          // Get the primary address

          Ipv4InterfaceAddress iaddr = ipv4->GetAddress (i, 0);

          Ipv4Address addri = iaddr.GetLocal ();

          Ipv4Mask maski = iaddr.GetMask ();

          if (maski == Ipv4Mask::GetOnes ())

            {

              // if the network mask is 255.255.255.255, do not convert dest

              NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << dest

                            << " (mask is " << maski << ")");

              m_udp->Send (p->Copy (), addri, dest,

                           m_endPoint->GetLocalPort (), port);

              NotifyDataSent (p->GetSize ());

              NotifySend (GetTxAvailable ());

            }

          else

            {

              // Convert to subnet-directed broadcast

              Ipv4Address bcast = addri.GetSubnetDirectedBroadcast (maski);

              NS_LOG_LOGIC ("Sending one copy from " << addri << " to " << bcast

                            << " (mask is " << maski << ")");

              m_udp->Send (p->Copy (), addri, bcast,

                           m_endPoint->GetLocalPort (), port);

              NotifyDataSent (p->GetSize ());

              NotifySend (GetTxAvailable ());

            }

        }

      NS_LOG_LOGIC ("Limited broadcast end.");

      return p->GetSize();

    }

  else if (ipv4->GetRoutingProtocol () != 0)

    {

      Ipv4Header header;

      header.SetDestination (dest);

      Socket::SocketErrno errno;

      Ptr<Ipv4Route> route;

      uint32_t oif = 0; //specify non-zero if bound to a source address

      // TBD-- we could cache the route and just check its validity

      route = ipv4->GetRoutingProtocol ()->RouteOutput (header, oif, errno); 

      if (route != 0)

        {

          NS_LOG_LOGIC ("Route exists");

          header.SetSource (route->GetSource ());

          m_udp->Send (p->Copy (), header.GetSource (), header.GetDestination (),

                       m_endPoint->GetLocalPort (), port, route);

          NotifyDataSent (p->GetSize ());

          return p->GetSize();

        }

      else 

        {

          NS_LOG_LOGIC ("No route to destination");

          NS_LOG_ERROR (errno);

          m_errno = errno;

          return -1;

        }

    }

  else

   {

      NS_LOG_ERROR ("ERROR_NOROUTETOHOST");

      m_errno = ERROR_NOROUTETOHOST;

      return -1;

   }

  return 0;

}

// XXX maximum message size for UDP broadcast is limited by MTU

// size of underlying link; we are not checking that now.

uint32_t

UdpSocketImpl::GetTxAvailable (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  // No finite send buffer is modelled, but we must respect

  // the maximum size of an IP datagram (65535 bytes - headers).

  return MAX_IPV4_UDP_DATAGRAM_SIZE;

}

int 

UdpSocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)

{

  NS_LOG_FUNCTION (this << p << flags << address);

  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);

  Ipv4Address ipv4 = transport.GetIpv4 ();

  uint16_t port = transport.GetPort ();

  return DoSendTo (p, ipv4, port);

}

uint32_t

UdpSocketImpl::GetRxAvailable (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  // We separately maintain this state to avoid walking the queue 

  // every time this might be called

  return m_rxAvailable;

}

Ptr<Packet>

UdpSocketImpl::Recv (uint32_t maxSize, uint32_t flags)

{

  NS_LOG_FUNCTION (this << maxSize << flags);

  if (m_deliveryQueue.empty() )

    {

      m_errno = ERROR_AGAIN;

      return 0;

    }

  Ptr<Packet> p = m_deliveryQueue.front ();

  if (p->GetSize () <= maxSize) 

    {

      m_deliveryQueue.pop ();

      m_rxAvailable -= p->GetSize ();

    }

  else

    {

      p = 0; 

    }

  return p;

}

Ptr<Packet>

UdpSocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags, 

  Address &fromAddress)

{