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

 //

 // Copyright (c) 2006 Georgia Tech Research Corporation

 // All rights reserved.

 //

 // 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: George F. Riley<riley@ece.gatech.edu>

 //

 #include "ns3/packet.h"

 #include "ns3/log.h"

 #include "ns3/composite-trace-resolver.h"

 #include "ns3/callback.h"

 #include "ns3/ipv4-address.h"

 #include "ns3/ipv4-route.h"

 #include "ns3/node.h"

 #include "ns3/net-device.h"

 #include "ipv4-l3-protocol.h"

 #include "ipv4-l4-protocol.h"

 #include "ipv4-header.h"

 #include "ipv4-interface.h"

 #include "ipv4-loopback-interface.h"

 #include "arp-ipv4-interface.h"

 #include "ipv4-l4-demux.h"

 NS_LOG_COMPONENT_DEFINE ("Ipv4L3Protocol");

 namespace ns3 {

 const uint16_t Ipv4L3Protocol::PROT_NUMBER = 0x0800;

 NS_OBJECT_ENSURE_REGISTERED (Ipv4L3Protocol);

 TypeId 

 Ipv4L3Protocol::GetTypeId (void)

 {

   static TypeId tid = TypeId ("Ipv4L3Protocol")

     .SetParent<Object> ();

   return tid;

 }

 Ipv4L3ProtocolTraceContextElement::Ipv4L3ProtocolTraceContextElement ()

   : m_type (TX)

 {

   NS_LOG_FUNCTION;

 }

 Ipv4L3ProtocolTraceContextElement::Ipv4L3ProtocolTraceContextElement (enum Type type)

   : m_type (type)

 {

   NS_LOG_FUNCTION;

 }

 bool 

 Ipv4L3ProtocolTraceContextElement::IsTx (void) const

 {

   NS_LOG_FUNCTION;

   return m_type == TX;

 }

 bool 

 Ipv4L3ProtocolTraceContextElement::IsRx (void) const

 {

   NS_LOG_FUNCTION;

   return m_type == RX;

 }

 bool 

 Ipv4L3ProtocolTraceContextElement::IsDrop (void) const

 {

   NS_LOG_FUNCTION;

   return m_type == DROP;

 }

 void 

 Ipv4L3ProtocolTraceContextElement::Print (std::ostream &os) const

 {

   NS_LOG_FUNCTION;

   os << "ipv4=";

   switch (m_type)

     {

     case TX:

       os << "tx";

       break;

     case RX:

       os << "rx";

       break;

     case DROP:

       os << "drop";

       break;

     }

 }

 uint16_t 

 Ipv4L3ProtocolTraceContextElement::GetUid (void)

 {

   NS_LOG_FUNCTION;

   static uint16_t uid = AllocateUid<Ipv4L3ProtocolTraceContextElement> ("Ipv4L3ProtocolTraceContextElement");

   return uid;

 }

 std::string 

 Ipv4L3ProtocolTraceContextElement::GetTypeName (void) const

 {

   NS_LOG_FUNCTION;

   return "ns3::Ipv4L3ProtocolTraceContextElement";

 }

 Ipv4L3ProtocolInterfaceIndex::Ipv4L3ProtocolInterfaceIndex ()

   : m_index (0)

 {

   NS_LOG_FUNCTION;

 }

 Ipv4L3ProtocolInterfaceIndex::Ipv4L3ProtocolInterfaceIndex (uint32_t index)

   : m_index (index)

 {

   NS_LOG_FUNCTION;

 }

 uint32_t 

 Ipv4L3ProtocolInterfaceIndex::Get (void) const

 {

   NS_LOG_FUNCTION;

   return m_index;

 }

 void 

 Ipv4L3ProtocolInterfaceIndex::Print (std::ostream &os) const

 {

   os << "ipv4-interface=" << m_index;

 }

 uint16_t 

 Ipv4L3ProtocolInterfaceIndex::GetUid (void)

 {

   NS_LOG_FUNCTION;

   static uint16_t uid = AllocateUid<Ipv4L3ProtocolInterfaceIndex> ("Ipv4L3ProtocolInterfaceIndex");

   return uid;

 }

 std::string

 Ipv4L3ProtocolInterfaceIndex::GetTypeName (void) const

 {

   NS_LOG_FUNCTION;

   return "ns3::Ipv4L3ProtocolInterfaceIndex";

 }

 Ipv4L3Protocol::Ipv4L3Protocol(Ptr<Node> node)

   : m_nInterfaces (0),

     m_defaultTtl (64),

     m_identification (0),

     m_node (node)

 {

   NS_LOG_FUNCTION;

   m_staticRouting = CreateObject<Ipv4StaticRouting> ();

   AddRoutingProtocol (m_staticRouting, 0);

   SetupLoopback ();

 }

 Ipv4L3Protocol::~Ipv4L3Protocol ()

 {

   NS_LOG_FUNCTION;

 }

 void 

 Ipv4L3Protocol::DoDispose (void)

 {

   NS_LOG_FUNCTION;

   m_interfaces.clear ();

   m_node = 0;

   m_staticRouting->Dispose ();

   m_staticRouting = 0;

   Object::DoDispose ();

 }

 void

 Ipv4L3Protocol::SetupLoopback (void)

 {

   NS_LOG_FUNCTION;

   Ptr<Ipv4LoopbackInterface> interface = CreateObject<Ipv4LoopbackInterface> (m_node);

   interface->SetAddress (Ipv4Address::GetLoopback ());

   interface->SetNetworkMask (Ipv4Mask::GetLoopback ());

   uint32_t index = AddIpv4Interface (interface);

   AddHostRouteTo (Ipv4Address::GetLoopback (), index);

   interface->SetUp ();

 }

 Ptr<TraceResolver>

 Ipv4L3Protocol::GetTraceResolver (void) const

 {

   NS_LOG_FUNCTION;

   Ptr<CompositeTraceResolver> resolver = Create<CompositeTraceResolver> ();

   resolver->AddSource ("tx", 

                        TraceDoc ("send ipv4 packet to outgoing interface",

                                  "Ptr<const Packet>", "packet sent",

                                  "uint32_t", "index of output ipv4 interface"),

                        m_txTrace, Ipv4L3ProtocolTraceContextElement(Ipv4L3ProtocolTraceContextElement::TX));

   resolver->AddSource ("rx",

                        TraceDoc ("receive ipv4 packet from incoming interface",

                                  "Ptr<const Packet>", "packet received",

                                  "uint32_t", "index of input ipv4 interface"),

                        m_rxTrace, Ipv4L3ProtocolTraceContextElement(Ipv4L3ProtocolTraceContextElement::RX));

   resolver->AddSource ("drop", 

                        TraceDoc ("drop ipv4 packet",

                                  "Ptr<const Packet>", "packet dropped"),

                        m_dropTrace, Ipv4L3ProtocolTraceContextElement (Ipv4L3ProtocolTraceContextElement::DROP));

   resolver->AddArray ("interfaces", 

                       m_interfaces.begin (), m_interfaces.end (), 

                       Ipv4L3ProtocolInterfaceIndex ());

   return resolver;

 }

 void 

 Ipv4L3Protocol::SetDefaultTtl (uint8_t ttl)

 {

   NS_LOG_FUNCTION;

   m_defaultTtl = ttl;

 }

 void 

 Ipv4L3Protocol::AddHostRouteTo (Ipv4Address dest, 

                       Ipv4Address nextHop, 

                       uint32_t interface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << dest << nextHop << interface);

   m_staticRouting->AddHostRouteTo (dest, nextHop, interface);

 }

 void 

 Ipv4L3Protocol::AddHostRouteTo (Ipv4Address dest, 

 				uint32_t interface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << dest << interface);

   m_staticRouting->AddHostRouteTo (dest, interface);

 }

 void 

 Ipv4L3Protocol::AddNetworkRouteTo (Ipv4Address network, 

 				   Ipv4Mask networkMask, 

 				   Ipv4Address nextHop, 

 				   uint32_t interface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << network << networkMask << nextHop << interface);

   m_staticRouting->AddNetworkRouteTo (network, networkMask, nextHop, interface);

 }

 void 

 Ipv4L3Protocol::AddNetworkRouteTo (Ipv4Address network, 

 				   Ipv4Mask networkMask, 

 				   uint32_t interface)

 {

   NS_LOG_FUNCTION; 

   NS_LOG_PARAMS (this << network << networkMask << interface);

   m_staticRouting->AddNetworkRouteTo (network, networkMask, interface);

 }

 void 

 Ipv4L3Protocol::SetDefaultRoute (Ipv4Address nextHop, 

 				 uint32_t interface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << nextHop << interface);

   m_staticRouting->SetDefaultRoute (nextHop, interface);

 }

 void

 Ipv4L3Protocol::Lookup (

   Ipv4Header const &ipHeader,

   Ptr<Packet> packet,

   Ipv4RoutingProtocol::RouteReplyCallback routeReply)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << &ipHeader << packet << &routeReply);

   Lookup (Ipv4RoutingProtocol::IF_INDEX_ANY, ipHeader, packet, routeReply);

 }

 void

 Ipv4L3Protocol::Lookup (

   uint32_t ifIndex,

   Ipv4Header const &ipHeader,

   Ptr<Packet> packet,

   Ipv4RoutingProtocol::RouteReplyCallback routeReply)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << ifIndex << &ipHeader << packet << &routeReply);

   for (Ipv4RoutingProtocolList::const_iterator rprotoIter = 

          m_routingProtocols.begin ();

        rprotoIter != m_routingProtocols.end (); 

        rprotoIter++)

     {

       NS_LOG_LOGIC ("Requesting route");

       if ((*rprotoIter).second->RequestRoute (ifIndex, ipHeader, packet, 

                                               routeReply))

         return;

     }

   if (ipHeader.GetDestination ().IsMulticast () && 

       ifIndex == Ipv4RoutingProtocol::IF_INDEX_ANY)

     {

       NS_LOG_LOGIC ("Multicast destination with local source");

 //

 // We have a multicast packet originating from the current node and were not

 // able to send it using the usual RequestRoute process.  Since the usual

 // process includes trying to use a default multicast route, this means that

 // there was no specific route out of the node found, and there was no default

 // multicast route set.

 //

 // The fallback position is to look for a default unicast route and use that

 // to get the packet off the node if we have one.

 //

       Ipv4Route *route = m_staticRouting->GetDefaultRoute ();

       if (route)

         {

           NS_LOG_LOGIC ("Local source. Using unicast default route for "

             "multicast packet");

           routeReply (true, *route, packet, ipHeader);

           return;

         }

     }

 //

 // No route found

 //

   routeReply (false, Ipv4Route (), packet, ipHeader);

 }

 void

 Ipv4L3Protocol::AddRoutingProtocol (Ptr<Ipv4RoutingProtocol> routingProtocol,

                                     int priority)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << &routingProtocol << priority);

   m_routingProtocols.push_back

     (std::pair<int, Ptr<Ipv4RoutingProtocol> > (-priority, routingProtocol));

   m_routingProtocols.sort ();

 }

 uint32_t 

 Ipv4L3Protocol::GetNRoutes (void)

 {

   NS_LOG_FUNCTION;

   return m_staticRouting->GetNRoutes ();

 }

 Ipv4Route *

 Ipv4L3Protocol::GetRoute (uint32_t index)

 {

   NS_LOG_FUNCTION;

   return m_staticRouting->GetRoute (index);

 }

 void 

 Ipv4L3Protocol::RemoveRoute (uint32_t index)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << index);

   m_staticRouting->RemoveRoute (index);

 }

 void 

 Ipv4L3Protocol::AddMulticastRoute (Ipv4Address origin,

                                    Ipv4Address group,

                                    uint32_t inputInterface,

                                    std::vector<uint32_t> outputInterfaces)

 {

   NS_LOG_FUNCTION; 

   NS_LOG_PARAMS (this << origin << group << inputInterface << &outputInterfaces);

   m_staticRouting->AddMulticastRoute (origin, group, inputInterface,

     outputInterfaces);

 }

 void 

 Ipv4L3Protocol::SetDefaultMulticastRoute (uint32_t outputInterface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << outputInterface);

   m_staticRouting->SetDefaultMulticastRoute (outputInterface);

 }

 uint32_t 

 Ipv4L3Protocol::GetNMulticastRoutes (void) const

 {

   NS_LOG_FUNCTION;

   return m_staticRouting->GetNMulticastRoutes ();

 }

 Ipv4MulticastRoute *

 Ipv4L3Protocol::GetMulticastRoute (uint32_t index) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << index);

   return m_staticRouting->GetMulticastRoute (index);

 }

 void 

 Ipv4L3Protocol::RemoveMulticastRoute (Ipv4Address origin,

                                        Ipv4Address group,

                                        uint32_t inputInterface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << origin << group << inputInterface);

   m_staticRouting->RemoveMulticastRoute (origin, group, inputInterface);

 }

 void 

 Ipv4L3Protocol::RemoveMulticastRoute (uint32_t index)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << index);

   m_staticRouting->RemoveMulticastRoute (index);

 }

 uint32_t 

 Ipv4L3Protocol::AddInterface (Ptr<NetDevice> device)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << &device);

   Ptr<Ipv4Interface> interface = CreateObject<ArpIpv4Interface> (m_node, device);

   return AddIpv4Interface (interface);

 }

 uint32_t 

 Ipv4L3Protocol::AddIpv4Interface (Ptr<Ipv4Interface>interface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << interface);

   uint32_t index = m_nInterfaces;

   m_interfaces.push_back (interface);

   m_nInterfaces++;

   return index;

 }

 Ptr<Ipv4Interface>

 Ipv4L3Protocol::GetInterface (uint32_t index) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << index);

   uint32_t tmp = 0;

   for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)

     {

       if (index == tmp) 

 	{

 	  return *i;

 	}

       tmp++;

     }

   return 0;

 }

 uint32_t 

 Ipv4L3Protocol::GetNInterfaces (void) const

 {

   NS_LOG_FUNCTION;

   return m_nInterfaces;

 }

 uint32_t 

 Ipv4L3Protocol::FindInterfaceForAddr (Ipv4Address addr) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << addr);

   uint32_t ifIndex = 0;

   for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

        i != m_interfaces.end (); 

        i++, ifIndex++)

     {

       if ((*i)->GetAddress () == addr)

         {

           return ifIndex;

         }

     }

   NS_ASSERT_MSG(false, "Ipv4L3Protocol::FindInterfaceForAddr (): "

     "Interface not found for IP address");

   return 0;

 }

 uint32_t 

 Ipv4L3Protocol::FindInterfaceForAddr (Ipv4Address addr, Ipv4Mask mask) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << addr << mask);

   uint32_t ifIndex = 0;

   for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

        i != m_interfaces.end (); 

        i++, ifIndex++)

     {

       if ((*i)->GetAddress ().CombineMask (mask) == addr.CombineMask (mask))

         {

           return ifIndex;

         }

     }

   NS_ASSERT_MSG(false, "Ipv4L3Protocol::FindInterfaceForAddr (): "

     "Interface not found for masked IP address");

   return 0;

 }

 Ptr<Ipv4Interface>

 Ipv4L3Protocol::FindInterfaceForDevice (Ptr<const NetDevice> device)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << &device);

   for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)

     {

       if ((*i)->GetDevice () == device)

         {

           return *i;

         }

     }

   return 0;

 }  

 void 

 Ipv4L3Protocol::Receive( Ptr<NetDevice> device, Ptr<Packet> packet, uint16_t protocol, const Address &from)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << &device << packet << protocol <<  from);

   NS_LOG_LOGIC ("Packet from " << from);

   uint32_t index = 0;

   Ptr<Ipv4Interface> ipv4Interface;

   for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

        i != m_interfaces.end (); 

        i++)

     {

       ipv4Interface = *i;

       if (ipv4Interface->GetDevice () == device)

         {

           m_rxTrace (packet, index);

           break;

         }

       index++;

     }

   Ipv4Header ipHeader;

   packet->RemoveHeader (ipHeader);

   if (!ipHeader.IsChecksumOk ()) 

     {

       return;

     }

   if (Forwarding (index, packet, ipHeader, device)) 

     {

       return;

     }

   NS_LOG_LOGIC ("Forward up");

   ForwardUp (packet, ipHeader, ipv4Interface);

 }

 void 

 Ipv4L3Protocol::Send (Ptr<Packet> packet, 

             Ipv4Address source, 

             Ipv4Address destination,

             uint8_t protocol)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << packet << source << destination << protocol);

   Ipv4Header ipHeader;

   ipHeader.SetSource (source);

   ipHeader.SetDestination (destination);

   ipHeader.SetProtocol (protocol);

   ipHeader.SetPayloadSize (packet->GetSize ());

   ipHeader.SetTtl (m_defaultTtl);

   ipHeader.SetMayFragment ();

   ipHeader.SetIdentification (m_identification);

   m_identification ++;

   if (destination.IsBroadcast ())

     {

       uint32_t ifaceIndex = 0;

       for (Ipv4InterfaceList::iterator ifaceIter = m_interfaces.begin ();

            ifaceIter != m_interfaces.end (); ifaceIter++, ifaceIndex++)

         {

           Ptr<Ipv4Interface> outInterface = *ifaceIter;

           Ptr<Packet> packetCopy = packet->Copy ();

           NS_ASSERT (packetCopy->GetSize () <= outInterface->GetMtu ());

           packetCopy->AddHeader (ipHeader);

           m_txTrace (packetCopy, ifaceIndex);

           outInterface->Send (packetCopy, destination);

         }

     }

   else

     {

       // XXX Note here that in most ipv4 stacks in the world,

       // the route calculation for an outgoing packet is not

       // done in the ip layer. It is done within the application

       // socket when the first packet is sent to avoid this

       // costly lookup on a per-packet basis.

       // That would require us to get the route from the packet,

       // most likely with a packet tag. The higher layers do not

       // do this yet for us.

       Lookup (ipHeader, packet,

               MakeCallback (&Ipv4L3Protocol::SendRealOut, this));

     }

 }

 void

 Ipv4L3Protocol::SendRealOut (bool found,

                              Ipv4Route const &route,

                              Ptr<Packet> packet,

                              Ipv4Header const &ipHeader)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << found << &route << packet << &ipHeader);

   packet->AddHeader (ipHeader);

   if (!found)

     {

       NS_LOG_WARN ("No route to host.  Drop.");

       m_dropTrace (packet);

       return;

     }

   NS_LOG_LOGIC ("Send via interface " << route.GetInterface ());

   Ptr<Ipv4Interface> outInterface = GetInterface (route.GetInterface ());

   NS_ASSERT (packet->GetSize () <= outInterface->GetMtu ());

   m_txTrace (packet, route.GetInterface ());

   if (route.IsGateway ()) 

     {

       NS_LOG_LOGIC ("Send to gateway " << route.GetGateway ());

       outInterface->Send (packet, route.GetGateway ());

     } 

   else 

     {

       NS_LOG_LOGIC ("Send to destination " << ipHeader.GetDestination ());

       outInterface->Send (packet, ipHeader.GetDestination ());

     }

 }

 bool

 Ipv4L3Protocol::Forwarding (

   uint32_t ifIndex, 

   Ptr<Packet> packet, 

   Ipv4Header &ipHeader, 

   Ptr<NetDevice> device)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (ifIndex << packet << &ipHeader<< device);

   for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin ();

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

     {

       if ((*i)->GetAddress ().IsEqual (ipHeader.GetDestination ())) 

         {

           NS_LOG_LOGIC ("For me (destination match)");

           return false;

         }

     }

   for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin ();

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

     {

       Ptr<Ipv4Interface> interface = *i;

       if (interface->GetDevice () == device)

 	{

 	  if (ipHeader.GetDestination ().IsEqual (interface->GetBroadcast ())) 

 	    {

               NS_LOG_LOGIC ("For me (interface broadcast address)");

 	      return false;

 	    }

 	  break;

 	}

     }

   if (ipHeader.GetDestination ().IsBroadcast ()) 

     {

       NS_LOG_LOGIC ("For me (Ipv4Addr broadcast address)");

       return false;

     }

   if (ipHeader.GetDestination ().IsEqual (Ipv4Address::GetAny ())) 

     {

       NS_LOG_LOGIC ("For me (Ipv4Addr any address)");

       return false;

     }

   if (ipHeader.GetTtl () == 1) 

     {

       // Should send ttl expired here

       // XXX

       NS_LOG_LOGIC ("Not for me (TTL expired).  Drop");

       m_dropTrace (packet);

       return true;

     }

   ipHeader.SetTtl (ipHeader.GetTtl () - 1);

   NS_LOG_LOGIC ("Forwarding packet.");

   Lookup (ifIndex, ipHeader, packet,

           MakeCallback (&Ipv4L3Protocol::SendRealOut, this));

 //

 // If this is a to a multicast address and this node is a member of the 

 // indicated group we need to return false so the multicast is forwarded up.

 // Note that we may have just forwarded this packet too.

 //

   for (Ipv4MulticastGroupList::const_iterator i = m_multicastGroups.begin ();

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

     {

       if ((*i).first.IsEqual (ipHeader.GetSource ()) &&

           (*i).second.IsEqual (ipHeader.GetDestination ()))

         {

           NS_LOG_LOGIC ("For me (Joined multicast group)");

           return false;

         }

     }

   NS_LOG_LOGIC("Not for me.");

   return true;

 }

 void

 Ipv4L3Protocol::ForwardUp (Ptr<Packet> p, Ipv4Header const&ip,

                            Ptr<Ipv4Interface> incomingInterface)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << p << &ip);

   Ptr<Ipv4L4Demux> demux = m_node->GetObject<Ipv4L4Demux> ();

   Ptr<Ipv4L4Protocol> protocol = demux->GetProtocol (ip.GetProtocol ());

   protocol->Receive (p, ip.GetSource (), ip.GetDestination (), incomingInterface);

 }

 void 

 Ipv4L3Protocol::JoinMulticastGroup (Ipv4Address origin, Ipv4Address group)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << origin << group);

   m_multicastGroups.push_back(

     std::pair<Ipv4Address, Ipv4Address> (origin, group));

 }

 void

 Ipv4L3Protocol::LeaveMulticastGroup (Ipv4Address origin, Ipv4Address group)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << origin << group);

   for (Ipv4MulticastGroupList::iterator i = m_multicastGroups.begin ();

        i != m_multicastGroups.end (); 

        i++)

     {

       if ((*i).first.IsEqual(origin) && (*i).second.IsEqual(group))

         {

           m_multicastGroups.erase (i);

           return;

         }

     }

 }

 void 

 Ipv4L3Protocol::SetAddress (uint32_t i, Ipv4Address address)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << i << address);

   Ptr<Ipv4Interface> interface = GetInterface (i);

   interface->SetAddress (address);

 }

 void 

 Ipv4L3Protocol::SetNetworkMask (uint32_t i, Ipv4Mask mask)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << i << mask);

   Ptr<Ipv4Interface> interface = GetInterface (i);

   interface->SetNetworkMask (mask);

 }

 Ipv4Mask 

 Ipv4L3Protocol::GetNetworkMask (uint32_t i) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << i);

   Ptr<Ipv4Interface> interface = GetInterface (i);

   return interface->GetNetworkMask ();

 }

 Ipv4Address 

 Ipv4L3Protocol::GetAddress (uint32_t i) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << i);

   Ptr<Ipv4Interface> interface = GetInterface (i);

   return interface->GetAddress ();

 }

 void 

 Ipv4L3Protocol::SetMetric (uint32_t i, uint16_t metric)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS ("(" << i << ", " << metric << ")");

   Ptr<Ipv4Interface> interface = GetInterface (i);

   interface->SetMetric (metric);

 }

 uint16_t

 Ipv4L3Protocol::GetMetric (uint32_t i) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS ("(" << i << ")");

   Ptr<Ipv4Interface> interface = GetInterface (i);

   return interface->GetMetric ();

 }

 bool

 Ipv4L3Protocol::GetIfIndexForDestination (

   Ipv4Address destination, uint32_t& ifIndex) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << destination << &ifIndex);

 //

 // The first thing we do in trying to determine a source address is to 

 // consult the routing protocols.  These will also check for a default route

 // if one has been set.

 //

   for (Ipv4RoutingProtocolList::const_iterator i = m_routingProtocols.begin ();

        i != m_routingProtocols.end (); 

        i++)

     {

       NS_LOG_LOGIC ("Requesting Source Address");

       uint32_t ifIndexTmp;

       if ((*i).second->RequestIfIndex (destination, ifIndexTmp))

         {

           NS_LOG_LOGIC ("Found ifIndex " << ifIndexTmp);

           ifIndex = ifIndexTmp;

           return true;

         }

     }

 //

 // If there's no routing table entry telling us what *single* interface will 

 // be used to send a packet to this destination, we'll have to just pick one.  

 // If there's only one interface on this node, a good answer isn't very hard

 // to come up with.  Before jumping to any conclusions, remember that the 

 // zeroth interface is the loopback interface, so what we actually want is

 // a situation where there are exactly two interfaces on the node, in which

 // case interface one is the "single" interface connected to the outside world.

 //

   if (GetNInterfaces () == 2)

     {

       NS_LOG_LOGIC ("One Interface.  Using interface 1.");

       ifIndex = 1;

       return true;

     }

 //

 // If we fall through to here, we have a node with multiple interfaces and

 // no routes to guide us in determining what interface to choose.  Either

 // no default route was found (for unicast or multicast), or in the case of a

 // multicast, the default route contained multiple outbound interfaces.

 //

 // The fallback position is to just get the unicast default route and use 

 // the outgoing interface specified there.  We don't want to leave the source

 // address unset, so we just assert here.

 //

 // N.B. that in the case of a multicast with a route containing multiple

 // outgoing interfaces, the source address of packets from that node will be

 // set to the IP address of the interface set in the default unicast route.

 // Also, in the case of a broadcast, the same will be true.

 //

   NS_LOG_LOGIC ("Using default unicast route");

   Ipv4Route *route = m_staticRouting->GetDefaultRoute ();

   if (route == NULL)

     {

       NS_LOG_LOGIC ("Ipv4L3Protocol::GetIfIndexForDestination (): "

                     "Unable to determine outbound interface.  No default route set");

       return false;

     }

   ifIndex = route->GetInterface ();

   NS_LOG_LOGIC ("Default route specifies interface " << ifIndex);

   return true;

 }

 uint16_t 

 Ipv4L3Protocol::GetMtu (uint32_t i) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << i);

   Ptr<Ipv4Interface> interface = GetInterface (i);

   return interface->GetMtu ();

 }

 bool 

 Ipv4L3Protocol::IsUp (uint32_t i) const

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << i);

   Ptr<Ipv4Interface> interface = GetInterface (i);

   return interface->IsUp ();

 }

 void 

 Ipv4L3Protocol::SetUp (uint32_t i)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << i);

   Ptr<Ipv4Interface> interface = GetInterface (i);

   interface->SetUp ();

   // If interface address and network mask have been set, add a route

   // to the network of the interface (like e.g. ifconfig does on a

   // Linux box)

   if ((interface->GetAddress ()) != (Ipv4Address ())

       && (interface->GetNetworkMask ()) != (Ipv4Mask ()))

     {

       AddNetworkRouteTo (interface->GetAddress ().CombineMask (interface->GetNetworkMask ()),

                          interface->GetNetworkMask (), i);

     }

 }

 void 

 Ipv4L3Protocol::SetDown (uint32_t ifaceIndex)

 {

   NS_LOG_FUNCTION;

   NS_LOG_PARAMS (this << ifaceIndex);

   Ptr<Ipv4Interface> interface = GetInterface (ifaceIndex);

   interface->SetDown ();

   // Remove all routes that are going through this interface

   bool modified = true;

   while (modified)

     {

       modified = false;

       for (uint32_t i = 0; i < GetNRoutes (); i++)

         {

           Ipv4Route *route = GetRoute (i);

           if (route->GetInterface () == ifaceIndex)

             {

               RemoveRoute (i);

               modified = true;

               break;

             }

         }

     }

 }

 }//namespace ns3