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

/*

 * Copyright (c) 2008 Liu Jian

 *

 * 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: Liu Jian <liujatp@gmail.com>

 *         Hajime Tazaki <tazaki@sfc.wide.ad.jp>

 */

#include "netlink-socket.h"

#include "netlink-socket-address.h"

#include "netlink-message.h"

#include "netlink-message-route.h"

#include "ns3/log.h"

#include "ns3/node.h"

#include "ns3/packet.h"

#include "ns3/ipv4-address.h"

#include "ns3/ipv4.h"

#include "ns3/simple-net-device.h"

#include "ns3/uinteger.h"

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

#include <iostream>

#include <sstream>

#include "ns3/ipv6-address.h"

#include "ns3/ipv6.h"

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

#include "ns3/ipv4-static-routing-helper.h"

#include "ns3/ipv4-routing-table-entry.h"

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

#include "ns3/ipv6-interface.h"

#include "ns3/ipv6-static-routing-helper.h"

#include "ns3/ipv6-routing-table-entry.h"

#include "ns3/socket.h"

#include "ns3/mac48-address.h"

#include <sys/socket.h>

#include <linux/if.h>

#include <errno.h>

NS_LOG_COMPONENT_DEFINE ("NetlinkSocket");

namespace ns3 {

// GroupSockets store the netlinksocket with noero group value

// it was due to the mulitcast netlink messages.

class GroupSockets

{

public:

  static uint32_t GetNSockets(void)

  { 

    return m_Sockets.size();

  }

  static Ptr<NetlinkSocket> GetSocket(uint32_t index)

  {

    NS_ASSERT(index < m_Sockets.size());

    return m_Sockets[index];

  }

  static void AddSocket(Ptr<NetlinkSocket>sock)

  {

    m_Sockets.push_back(sock);

  }

private:

   /*use a std::vector to store the sockets with nozero group value*/

  static std::vector<Ptr<NetlinkSocket> >m_Sockets;

};

std::vector<Ptr<NetlinkSocket> >GroupSockets::m_Sockets;

NS_OBJECT_ENSURE_REGISTERED (NetlinkSocket);

/*

Netlink Socket

*/

TypeId

NetlinkSocket::GetTypeId (void)

{

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

    .SetParent<Socket> ()

    .AddConstructor<NetlinkSocket> ()

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

                     MakeTraceSourceAccessor (&NetlinkSocket::m_dropTrace))

    .AddAttribute ("RcvBufSize",

                   "NetlinkSocket maximum receive buffer size (bytes)",

                   UintegerValue (0xffffffffl),

                   MakeUintegerAccessor (&NetlinkSocket::m_rcvBufSize),

                   MakeUintegerChecker<uint32_t> ())

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

                   CallbackValue (),

                   MakeCallbackAccessor (&NetlinkSocket::m_icmpCallback),

                   MakeCallbackChecker ())

    ;

  return tid;

}

NetlinkSocket::NetlinkSocket ()

  : m_shutdownSend (false),

    m_shutdownRecv (false),

    m_rxAvailable (0),

    m_srcPid (0),

    m_srcGroups (0),

    m_dstPid (0),

    m_dstGroups (0)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_errno = ERROR_NOTERROR;

}

NetlinkSocket::~NetlinkSocket ()

{

  NS_LOG_FUNCTION (this);

}

void 

NetlinkSocket::DoDispose (void)

{

  NS_LOG_FUNCTION_NOARGS ();

}

int

NetlinkSocket::ErrnoToSimuErrno (void)

{

  switch (m_errno)

    {

    case Socket::ERROR_ISCONN:

      return EISCONN;

    case Socket::ERROR_NOTCONN:

      return ENOTCONN;

    case Socket::ERROR_MSGSIZE:

      return EMSGSIZE;

    case Socket::ERROR_AGAIN:

      return EAGAIN;

    case Socket::ERROR_SHUTDOWN:

      return ESHUTDOWN;

    case Socket::ERROR_OPNOTSUPP:

      return EOPNOTSUPP;

    case Socket::ERROR_AFNOSUPPORT:

      return EAFNOSUPPORT;

    case Socket::ERROR_INVAL:

      return EINVAL;

    case Socket::ERROR_BADF:

      return EBADF;

    case Socket::ERROR_NOROUTETOHOST:

      return EHOSTUNREACH;

    case Socket::ERROR_NODEV:

      return ENODEV;

    case Socket::ERROR_ADDRNOTAVAIL:

      return EADDRNOTAVAIL;

    case Socket::SOCKET_ERRNO_LAST:

    case Socket::ERROR_NOTERROR:

    default:

      NS_ASSERT (false);

      return 0; // quiet compiler

      break;

    }

}

void 

NetlinkSocket::SetNode (Ptr<Node> node)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_node = node;

}

enum Socket::SocketErrno

NetlinkSocket::GetErrno (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_errno;

}

enum Socket::SocketType 

NetlinkSocket::GetSocketType (void) const

{

  return Socket::NS3_SOCK_DGRAM;

}

Ptr<Node>

NetlinkSocket::GetNode (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_node;

}

uint32_t

NetlinkSocket::GetSrcPid (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_srcPid;

}

uint32_t

NetlinkSocket::GetSrcGroups (void)const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_srcGroups;

}

uint32_t

NetlinkSocket::GetDstPid (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_dstPid;

}

uint32_t

NetlinkSocket::GetDstGroups (void)const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_dstGroups;

}

int

NetlinkSocket::Bind (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  NetlinkSocketAddress address;

  return DoBind (address);

}

int

NetlinkSocket::Bind (const Address &address)

{ 

  NS_LOG_FUNCTION (this << address);

  if (!NetlinkSocketAddress::IsMatchingType (address))

    {

      m_errno = ERROR_INVAL;

      return -1;

    }

  NetlinkSocketAddress ad = NetlinkSocketAddress::ConvertFrom (address);

  return DoBind (ad);

}

int

NetlinkSocket::DoBind (const NetlinkSocketAddress &address)

{

  NS_LOG_FUNCTION (this << address);

  m_srcPid = address.GetProcessID ();

  m_srcGroups = address.GetGroupsMask ();

  if (m_srcGroups)

    {

      GroupSockets::AddSocket(this);

    } 

  return 0;

}

int 

NetlinkSocket::Listen (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_errno = Socket::ERROR_OPNOTSUPP;

  return -1;

}

uint32_t

NetlinkSocket::GetTxAvailable (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return 0;

}

uint32_t

NetlinkSocket::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;

}

int

NetlinkSocket::ShutdownSend (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_shutdownSend = true;

  return 0;

}

int

NetlinkSocket::ShutdownRecv (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_shutdownRecv = true;

  return 0;

}

int

NetlinkSocket::Close (void)

{

  NS_LOG_FUNCTION_NOARGS ();

  ShutdownSend();

  ShutdownRecv();

  return 0;

}

int

NetlinkSocket::Connect (const Address &address)

{

  NS_LOG_FUNCTION (this << address);

  m_errno = Socket::ERROR_OPNOTSUPP;

  return 0;

}

Ptr<Packet>

NetlinkSocket::Recv (uint32_t maxSize, uint32_t flags)

{

  NS_LOG_FUNCTION (this << maxSize<< flags);

  if (m_dataReceiveQueue.empty())

    {

      return 0;

    }

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

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

    {

      m_dataReceiveQueue.pop ();

      m_rxAvailable -= p->GetSize ();

    }

  else

    {

      p = 0; 

    }

  return p;

}

Ptr<Packet>

NetlinkSocket::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)

{

  NS_LOG_FUNCTION (this << maxSize << flags << fromAddress);

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

  if (packet != 0)

    {

      SocketAddressTag tag;

      bool found;

      found = packet->FindFirstMatchingByteTag (tag);

      NS_ASSERT (found);

      fromAddress = tag.GetAddress ();

    }

  return packet;

}

int

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

{

  NS_LOG_FUNCTION (this << p << flags);

  NetlinkSocketAddress address = NetlinkSocketAddress(m_dstPid, m_dstGroups);

  return SendTo(p, flags, address);

}

int

NetlinkSocket::SendTo (Ptr<Packet> p, uint32_t flags, const Address &toAddress)

{

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

  NetlinkSocketAddress ad;

  if (!NetlinkSocketAddress::IsMatchingType (toAddress))

    {

      NS_LOG_LOGIC ("ERROR_AFNOSUPPORT");

      m_errno = ERROR_AFNOSUPPORT;

      return -1;

    }

  ad = NetlinkSocketAddress::ConvertFrom (toAddress);

  m_dstPid = ad.GetProcessID();

  m_dstGroups = ad.GetGroupsMask();

  NS_LOG_INFO ("send netlink message to pid = " << m_dstPid << ", groups = " << m_dstGroups);

  NS_LOG_DEBUG (Simulator::Now ().GetSeconds () << " Sending netlink message from " << m_node->GetObject<Ipv4> ()->GetAddress (1, 0).GetLocal ());

  //Ptr<NetlinkSocket>kernel_socket = GetNetlinkSocketByAddress(ad);

  //kernel_socket->m_receivedData.push_back(p);

  //kernel_socket->NotifyDataReceived(p);

  //when netlink socket send packet, the first step is to find the dest netlink socket through address

  //then send the packet to it. For we partly implement the netlink-family, the dest address

  //is always the kernel(pid = 0), (Actually, there must be one static kernel netlink socket to

  //receive/handle messages), we do not setup a kernel socket to receive packet.

  //

  MultipartNetlinkMessage multipartnlmsg;

  uint32_t packet_len, remain_len;

  packet_len = p->GetSize ();

  remain_len = packet_len;

  while (remain_len > NetlinkMessageHeader::GetHeaderSize ())

    {

      remain_len -= p->RemoveHeader (multipartnlmsg);

      NS_ASSERT (remain_len == p->GetSize ());

      //actually, message to kernel contains single one netlink message

      for (uint32_t i = 0; i < multipartnlmsg.GetNMessages(); i ++)

        {

          NetlinkMessage nlmsg = multipartnlmsg.GetMessage (i);

          if (HandleMessage (nlmsg) < 0)

            {

              if (m_errno)

                {

                  SendAckMessage (nlmsg, -ErrnoToSimuErrno ());

                }

            }

          else if (NetlinkMessage::IsMessageFlagsAck (nlmsg.GetHeader ().GetMsgFlags ()))

            {

              SendAckMessage (nlmsg, 0);

            }

        }

    }

  NotifyDataSent (packet_len);

  NS_LOG_INFO ("netlink socket kernel error " << -m_errno);

  return packet_len;

}

int

NetlinkSocket::GetSockName (Address &address) const

{

  NS_LOG_FUNCTION_NOARGS ();

  NetlinkSocketAddress ad;

  ad.SetProcessID (GetSrcPid ());

  ad.SetGroupsMask (GetSrcGroups ());

  address = ad;

  return 0;

}

int

NetlinkSocket::GetPeerName (Address &address) const

{

  NS_LOG_FUNCTION_NOARGS ();

  // XXX

  NS_ASSERT (false);

  return -1;

}

bool 

NetlinkSocket::SetAllowBroadcast (bool allowBroadcast)

{

  NS_ASSERT (false);

  return false;

}

bool 

NetlinkSocket::GetAllowBroadcast () const

{

  NS_ASSERT (false);

  return false;

}

void

NetlinkSocket::ForwardUp (Ptr<Packet> packet, NetlinkSocketAddress &address)

{

  NS_LOG_FUNCTION (this << packet << address);

  if (m_shutdownRecv)

    {

      return;

    }

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

    {

      SocketAddressTag tag;

      tag.SetAddress (address);

      packet->AddByteTag (tag);

      m_dataReceiveQueue.push (packet);

      m_rxAvailable += packet->GetSize ();

      NotifyDataRecv ();

    }

  else

    {

      NS_LOG_WARN ("No receive buffer space available.  Drop.");

      m_dropTrace (packet);

    }

}

int32_t

NetlinkSocket::SendMessageUnicast (const MultipartNetlinkMessage &nlmsg, uint32_t pid, int32_t nonblock)

{

  NS_LOG_FUNCTION (this << pid << nonblock);

  //here we send message instantly

  Ptr<Packet> p = Create<Packet> ();

  p->AddHeader (nlmsg);

  NetlinkSocketAddress address;

  address.SetProcessID (pid);

  //send packet to user space

  ForwardUp (p, address);

  return 0;

}

int32_t

NetlinkSocket::SendMessageBroadcast (const MultipartNetlinkMessage &nlmsg, 

                                     uint32_t pid, 

                                     uint32_t group,

                                     Ptr<Node> node)

{

  NS_LOG_FUNCTION ("SendMessageBroadcast" << pid << group);

  //fisrt find the dest netlink socket through group value, then attach this nlmsg to its recv-queue

  for (uint32_t i = 0; i < GroupSockets::GetNSockets (); i ++)

    {

      Ptr<NetlinkSocket> nlsock = GroupSockets::GetSocket (i);

      if ((nlsock->GetSrcGroups () & group) &&

          (nlsock->GetSrcPid () != pid) &&

          node == nlsock->GetNode ())

        {

          //here we send message instantly

          Ptr<Packet> p = Create<Packet> ();

          p->AddHeader (nlmsg);

          NetlinkSocketAddress address;

          address.SetProcessID (nlsock->GetSrcPid());

          address.SetGroupsMask (group);

          //send packet to user space

          nlsock->ForwardUp (p, address);

        }

    }

  return 0;

}

void

NetlinkSocket::SendAckMessage (const NetlinkMessage&nlmsg, int32_t err)

{

  NS_LOG_FUNCTION (this << err);

  NetlinkMessageHeader rep;

  NetlinkMessage ackmsg;

  NetlinkMessageError errmsg;

  rep.SetMsgPid (nlmsg.GetHeader ().GetMsgPid ());

  rep.SetMsgSeq (nlmsg.GetHeader ().GetMsgSeq ());

  rep.SetMsgType (NETLINK_MSG_ERROR);