/* -*-  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/udp-socket-factory.h"

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

#include "ns3/uinteger.h"

#include "ns3/boolean.h"

#include "udp-socket-impl.h"

#include "udp-l4-protocol.h"

#include "ipv4-end-point.h"

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

    ;

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

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

      return ERROR_INVAL;

    }

  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 (uint32_t queueLimit)

{

  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;

    }

  uint32_t localIfIndex;

  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

  //NS_LOG_UNCOND ("IPttl: " << m_ipTtl);

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

    {

      SocketIpTtlTag tag;

      tag.SetTtl (m_ipMulticastTtl);

      p->AddTag (tag);

    }

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

    {

      SocketIpTtlTag tag;

      tag.SetTtl (m_ipTtl);

      p->AddTag (tag);

    }

  //

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

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

  //

  if (dest.IsBroadcast ())

    {

      NS_LOG_LOGIC ("Limited broadcast start.");

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

        {

          Ipv4Address addri = ipv4->GetAddress (i);

          Ipv4Mask maski = ipv4->GetNetworkMask (i);

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

        }

      NS_LOG_LOGIC ("Limited broadcast end.");

      return p->GetSize();

    }

  else if (ipv4->GetIfIndexForDestination(dest, localIfIndex))

    {

      NS_LOG_LOGIC ("Route exists");

      m_udp->Send (p->Copy (), ipv4->GetAddress (localIfIndex), dest,

		   m_endPoint->GetLocalPort (), port);

      NotifyDataSent (p->GetSize ());

      return p->GetSize();;

    }

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

    {

      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)

{

  NS_LOG_FUNCTION (this << maxSize << flags);

  Ptr<Packet> packet = Recv (maxSize, flags);

  if (packet != 0)

    {

      SocketAddressTag tag;

      bool found;

      found = packet->FindFirstMatchingTag (tag);

      NS_ASSERT (found);

      fromAddress = tag.GetAddress ();

    }

  return packet;

}

void 

UdpSocketImpl::ForwardUp (Ptr<Packet> packet, Ipv4Address ipv4, uint16_t port)

{

  NS_LOG_FUNCTION (this << packet << ipv4 << port);

  if (m_shutdownRecv)

    {

      return;

    }

  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)

    {

      Address address = InetSocketAddress (ipv4, port);

      SocketAddressTag tag;

      tag.SetAddress (address);

      packet->AddTag (tag);

      m_deliveryQueue.push (packet);

      m_rxAvailable += packet->GetSize ();

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

    }

}

void 

UdpSocketImpl::SetRcvBufSize (uint32_t size)

{

  m_rcvBufSize = size;

}

uint32_t 

UdpSocketImpl::GetRcvBufSize (void) const

{

  return m_rcvBufSize;

}

void 

UdpSocketImpl::SetIpTtl (uint32_t ipTtl)

{

  m_ipTtl = ipTtl;

}