#include <dlfcn.h>

 #include "ns3/boolean.h"

 #include "ns3/log.h"

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

 #include "ns3/ipv4-interface.h"

 #include "ns3/object.h"

 #include "ns3/packet.h"

 #include "ns3/ptr.h"

 #include "ns3/nstime.h"

 #include "nsc-glue.h"

 #include "node.h"

 #include <netinet/ip.h>

 #include <arpa/inet.h>

 namespace ns3 {

 NS_OBJECT_ENSURE_REGISTERED (NscGlue);

 TypeId

 NscGlue::GetTypeId (void)

 {

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

     .SetParent <Object> ()

     ;

   return tid;

 }

 NscGlue::NscGlue(void)

 	: m_wakeupCallbacks(0),

 	  m_dlopenHandle(0)

 {

 }

 void

 NscGlue::SetNode(Ptr<Node> n)

 {

   m_node = n;

 }

 void

 NscGlue::PassPacketToNsc (Ptr<const Packet> packet, int idx)

 {

   uint32_t packetSize = packet->GetSize();

   const uint8_t *data = const_cast<uint8_t *>(packet->PeekData());

   // deliver complete packet to the NSC network stack

   m_nscStack->if_receive_packet(idx, data, packetSize);

   wakeup ();

 }

 bool

 NscGlue::IsNscProtocol (uint16_t proto)

 {

   return proto == 0x0800; // NSC can only handle ipv4 at the moment.

 }

 static int external_rand(void)

 {

   return 1; // XXX: check which NSC stacks actually use this

 }

 void

 NscGlue::SetNscLibrary(const std::string &soname)

 {

   NS_ASSERT(!m_dlopenHandle);

   m_dlopenHandle = dlopen(soname.c_str (), RTLD_NOW);

   if (m_dlopenHandle == NULL)

     NS_FATAL_ERROR (dlerror());

   FCreateStack create = (FCreateStack)dlsym(m_dlopenHandle, "nsc_create_stack");

   m_nscStack = create(this, this, external_rand);

   int hzval = m_nscStack->get_hz();

   NS_ASSERT(hzval > 0);

   m_softTimer.SetFunction (&NscGlue::SoftRtcInterrupt, this);

   m_softTimer.SetDelay (MilliSeconds (1000/hzval));

   // This enables stack and NSC debug messages

   m_nscStack->set_diagnostic(10);

   m_nscStack->init(hzval);

   Ptr<Ns3NscStack> nscStack = Create<Ns3NscStack> ();

   nscStack->SetStack (m_nscStack);

   m_node->AggregateObject (nscStack);

   m_softTimer.Schedule ();

   // its likely no ns-3 interface exits at this point, so

   // we delay adding the nsc interface until the start of the simulation.

   Simulator::ScheduleNow(&NscGlue::AddIface, this);

   m_nscLibrary = soname;

 }

 std::string

 NscGlue::GetNscLibrary () const

 {

   return m_nscLibrary;

 }

 void NscGlue::wakeup()

 {

   // TODO

   // this should schedule a timer to read from all tcp sockets now... this is

   // an indication that data might be waiting on the socket

   for (std::list<Callback<void> >::iterator i = m_wakeupCallbacks.begin ();

 	i != m_wakeupCallbacks.end (); i++)

      {

         Callback<void> cb = *i;

 	cb ();

      }

 }

 void NscGlue::SoftRtcInterrupt (void)

 {

   m_nscStack->timer_interrupt ();

   m_nscStack->increment_ticks ();

   m_softTimer.Schedule ();

 }

 void NscGlue::gettime(unsigned int* sec, unsigned int* usec)

 {

   // Only used by the Linux network stack, e.g. during ISN generation

   // and in the kernel rng initialization routine. Also used in Linux

   // printk output.

   Time t = Simulator::Now ();

   int64_t us = t.GetMicroSeconds ();

   *sec = us / (1000*1000);

   *usec = us - *sec * (1000*1000);

 }

 #ifdef NSC_NEXT

 void NscGlue::send_callback(int idx, const void* data, unsigned int datalen)

 #else

 void NscGlue::send_callback(/* int idx,*/ const void* data, unsigned int datalen)

 #endif

 {

 #ifndef NSC_NEXT

  int idx = 0;

 #endif

   Ptr<Packet> p;

   uint32_t ipv4Daddr;

   NS_ASSERT(datalen > 20);

   // FIXME: XXX: This won't really work when NSC is able to use

   // L3 protocols other than AF_INET. We really really really

   // should be able to do all routing decisions inside nsc and just

   // pass packets to whatever network interface without looking at its contents.

   const uint8_t *rawdata = reinterpret_cast<const uint8_t *>(data);

   p = Create<Packet> (rawdata, datalen);

   // we need the destination ipv4 address for Send ().

   const uint32_t *ipheader = reinterpret_cast<const uint32_t *>(data);

   ipv4Daddr = *(ipheader+4);

   Ipv4Address daddr(ntohl(ipv4Daddr));

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

   NS_ASSERT_MSG (ipv4, "nsc callback invoked, but node has no ipv4 object");

   // FIXME: do _all_ routing via NSC and provide a ns3-nsc mapping that

   // tells us which ns-3 interface the nsc interface "idx" is corresponding to.

 //NS_LOG_LOGIC ("ns3: xmit via device number " << idx);

   Ptr<Ipv4Interface> outInterface = ipv4->GetInterface ( idx + 1);

   NS_ASSERT (outInterface);

   outInterface->Send (p, daddr);

   m_nscStack->if_send_finish(0);

 }

 void NscGlue::RegisterWakeupCallback(Callback<void> cb)

 {

   m_wakeupCallbacks.push_back (cb);

 }

 void NscGlue::AddIface(void)

 {

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

     const uint32_t nInterfaces = ip->GetNInterfaces ();

     // start from 1, ignore the loopback interface (HACK)

     for (uint32_t i = 1; i < nInterfaces; i++)

     {

       Ipv4InterfaceAddress ifAddr = ip->GetAddress (i, 0);

       Ipv4Address addr = ifAddr.GetLocal ();

       Ipv4Mask mask = ifAddr.GetMask ();

       uint16_t mtu = ip->GetMtu (i);

       std::ostringstream addrOss, maskOss;

       addr.Print(addrOss);

       mask.Print(maskOss);

 //    NS_LOG_LOGIC ("if_attach " << addrOss.str().c_str() << " " << maskOss.str().c_str() << " " << mtu);

       std::string addrStr = addrOss.str();

       std::string maskStr = maskOss.str();

       const char* addrCStr = addrStr.c_str();

       const char* maskCStr = maskStr.c_str();

       NS_ASSERT_MSG (m_nscStack, "m_nscStackError");

       m_nscStack->if_attach(addrCStr, maskCStr, mtu);

       if (i == 1)

       {

         // We need to come up with a default gateway here. Can't guarantee this to be

         // correct really...

         uint8_t addrBytes[4];

         addr.Serialize(addrBytes);

         // XXX: this is all a bit of a horrible hack

         //

         // Just increment the last octet, this gives a decent chance of this being

         // 'enough'.

         //

         // All we need is another address on the same network as the interface. This

         // will force the stack to output the packet out of the network interface.

         addrBytes[3]++;

         addr.Deserialize(addrBytes);

         addrOss.str("");

         addr.Print(addrOss);

         m_nscStack->add_default_gateway(addrOss.str().c_str());

       }

    }

 }

 } // namespace ns3