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

 /*

  * Copyright (c) 2006 Georgia Tech Research Corporation, 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

  *

  * Authors: George F. Riley<riley@ece.gatech.edu>

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

  */

 #include "node.h"

 #include "node-list.h"

 #include "net-device.h"

 #include "application.h"

 #include "ns3/packet.h"

 #include "ns3/simulator.h"

 #include "ns3/object-vector.h"

 #include "ns3/uinteger.h"

 #include "ns3/log.h"

 #include "ns3/assert.h"

 #include "ns3/global-value.h"

 #include "ns3/boolean.h"

 #include "nsc-glue.h"

 NS_LOG_COMPONENT_DEFINE ("Node");

 namespace ns3{

 NS_OBJECT_ENSURE_REGISTERED (Node);

 GlobalValue g_checksumEnabled  = GlobalValue ("ChecksumEnabled",

                                               "A global switch to enable all checksums for all protocols",

                                               BooleanValue (false),

                                               MakeBooleanChecker ());

 TypeId 

 Node::GetTypeId (void)

 {

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

     .SetParent<Object> ()

     .AddConstructor<Node> ()

     .AddAttribute ("DeviceList", "The list of devices associated to this Node.",

                    ObjectVectorValue (),

                    MakeObjectVectorAccessor (&Node::m_devices),

                    MakeObjectVectorChecker<NetDevice> ())

     .AddAttribute ("ApplicationList", "The list of applications associated to this Node.",

                    ObjectVectorValue (),

                    MakeObjectVectorAccessor (&Node::m_applications),

                    MakeObjectVectorChecker<Application> ())

     .AddAttribute ("Id", "The id (unique integer) of this Node.",

                    TypeId::ATTR_GET, // allow only getting it.

                    UintegerValue (0),

                    MakeUintegerAccessor (&Node::m_id),

                    MakeUintegerChecker<uint32_t> ())

     ;

   return tid;

 }

 Node::Node()

   : m_id(0), 

     m_sid(0),

     m_useNsc(false)

 {

   Construct ();

 }

 Node::Node(uint32_t sid)

   : m_id(0), 

     m_sid(sid)

 { 

   Construct ();

 }

 void

 Node::Construct (void)

 {

   m_id = NodeList::Add (this);

 }

 Node::~Node ()

 {}

 uint32_t 

 Node::GetId (void) const

 {

   return m_id;

 }

 uint32_t 

 Node::GetSystemId (void) const

 {

   return m_sid;

 }

 uint32_t 

 Node::AddDevice (Ptr<NetDevice> device)

 {

   uint32_t index = m_devices.size ();

   m_devices.push_back (device);

   device->SetNode (this);

   device->SetIfIndex(index);

   device->SetReceiveCallback (MakeCallback (&Node::NonPromiscReceiveFromDevice, this));

   NotifyDeviceAdded (device);

   return index;

 }

 Ptr<NetDevice>

 Node::GetDevice (uint32_t index) const

 {

   NS_ASSERT_MSG (index < m_devices.size (), "Device index " << index <<

                  " is out of range (only have " << m_devices.size () << " devices).");

   return m_devices[index];

 }

 uint32_t 

 Node::GetNDevices (void) const

 {

   return m_devices.size ();

 }

 uint32_t 

 Node::AddApplication (Ptr<Application> application)

 {

   uint32_t index = m_applications.size ();

   m_applications.push_back (application);

   application->SetNode (this);

   return index;

 }

 Ptr<Application> 

 Node::GetApplication (uint32_t index) const

 {

   NS_ASSERT_MSG (index < m_applications.size (), "Application index " << index <<

                  " is out of range (only have " << m_applications.size () << " applications).");

   return m_applications[index];

 }

 uint32_t 

 Node::GetNApplications (void) const

 {

   return m_applications.size ();

 }

 void 

 Node::DoDispose()

 {

   for (std::vector<Ptr<NetDevice> >::iterator i = m_devices.begin ();

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

     {

       Ptr<NetDevice> device = *i;

       device->Dispose ();

       *i = 0;

     }

   m_devices.clear ();

   for (std::vector<Ptr<Application> >::iterator i = m_applications.begin ();

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

     {

       Ptr<Application> application = *i;

       application->Dispose ();

       *i = 0;

     }

   m_applications.clear ();

   Object::DoDispose ();

 }

 void 

 Node::NotifyDeviceAdded (Ptr<NetDevice> device)

 {}

 void

 Node::RegisterProtocolHandler (ProtocolHandler handler, 

                                uint16_t protocolType,

                                Ptr<NetDevice> device,

                                bool promiscuous)

 {

   struct Node::ProtocolHandlerEntry entry;

   entry.handler = handler;

   entry.protocol = protocolType;

   entry.device = device;

   entry.promiscuous = promiscuous;

   // On demand enable promiscuous mode in netdevices

   if (promiscuous)

     {

       if (device == 0)

         {

           for (std::vector<Ptr<NetDevice> >::iterator i = m_devices.begin ();

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

             {

               Ptr<NetDevice> dev = *i;

               dev->SetPromiscReceiveCallback (MakeCallback (&Node::PromiscReceiveFromDevice, this));

             }

         }

       else

         {

           device->SetPromiscReceiveCallback (MakeCallback (&Node::PromiscReceiveFromDevice, this));

         }

     }

   m_handlers.push_back (entry);

 }

 void

 Node::UnregisterProtocolHandler (ProtocolHandler handler)

 {

   for (ProtocolHandlerList::iterator i = m_handlers.begin ();

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

     {

       if (i->handler.IsEqual (handler))

         {

           m_handlers.erase (i);

           break;

         }

     }

 }

 bool

 Node::ChecksumEnabled (void)

 {

   BooleanValue val;

   g_checksumEnabled.GetValue (val);

   return val.Get ();

 }

 bool

 Node::PromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol,

                                 const Address &from, const Address &to, NetDevice::PacketType packetType)

 {

   NS_LOG_FUNCTION(this);

   return ReceiveFromDevice (device, packet, protocol, from, to, packetType, true);

 }

 bool

 Node::NonPromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol,

                                    const Address &from)

 {

   NS_LOG_FUNCTION(this);

   return ReceiveFromDevice (device, packet, protocol, from, from, NetDevice::PacketType (0), false);

 }

 bool

 Node::ReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol,

                          const Address &from, const Address &to, NetDevice::PacketType packetType, bool promiscuous)

 {

   NS_LOG_DEBUG("Node " << GetId () << " ReceiveFromDevice:  dev "

                << device->GetIfIndex () << " (type=" << device->GetInstanceTypeId ().GetName ()

                << ") Packet UID " << packet->GetUid ());

   bool found = false;

   if (m_useNsc && m_nscGlue->IsNscProtocol (protocol)) {

       m_nscGlue->PassPacketToNsc (packet, 0); // 0: NSC interface ID. XXX: Map &device <-> nscindex

       return true;

   }

   for (ProtocolHandlerList::iterator i = m_handlers.begin ();

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

     {

       if (i->device == 0 ||

           (i->device != 0 && i->device == device))

         {

           if (i->protocol == 0 || 

               i->protocol == protocol)

             {

               if (promiscuous == i->promiscuous)

                 {

                   i->handler (device, packet, protocol, from, to, packetType);

                   found = true;

                 }

             }

         }

     }

   return found;

 }

 #ifdef NETWORK_SIMULATION_CRADLE

 void

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

 {

   m_nscGlue = CreateObject <NscGlue> ();

   m_nscGlue->SetNode (this);

   m_nscGlue->SetNscLibrary (soname);

   m_useNsc = true;

 }

 std::string

 Node::GetNscLibrary(void) const

 {

   return m_nscGlue->GetNscLibrary ();

 }

 INetStack *

 Node::GetNscInetStack(void)

 {

   NS_ASSERT_MSG(m_useNsc, "GetNscInetStack called, but nsc disabled on this node");

   return m_nscGlue->m_nscStack;

 }

 void Node::RegisterNscWakeupCallback(Callback<void> cb)

 {

   NS_ASSERT (m_nscGlue);

   m_nscGlue->RegisterWakeupCallback (cb);

 }

 #endif

 }//namespace ns3