| // -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- |
| // |
| // Copyright (c) 2006 Georgia Tech Research Corporation |
| // |
| // 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/callback.h" |
| #include "ns3/ccnx-address.h" |
| #include "ns3/ccnx-route.h" |
| #include "ns3/node.h" |
| #include "ns3/socket.h" |
| #include "ns3/net-device.h" |
| #include "ns3/uinteger.h" |
| #include "ns3/trace-source-accessor.h" |
| #include "ns3/object-vector.h" |
| #include "ns3/ccnx-header.h" |
| #include "ns3/boolean.h" |
| //#include "ns3/ccnx-routing-table-entry.h" |
| |
| #include "arp-l3-protocol.h" |
| #include "ccnx-l3-protocol.h" |
| #include "ccnx-interface.h" |
| |
| NS_LOG_COMPONENT_DEFINE ("CcnxL3Protocol"); |
| |
| namespace ns3 { |
| |
| const uint16_t CcnxL3Protocol::PROT_NUMBER = 0x7777; |
| |
| NS_OBJECT_ENSURE_REGISTERED (CcnxL3Protocol); |
| |
| TypeId |
| CcnxL3Protocol::GetTypeId (void) |
| { |
| static TypeId tid = TypeId ("ns3::CcnxL3Protocol") |
| .SetParent<Ccnx> () |
| .AddConstructor<CcnxL3Protocol> () |
| .AddTraceSource ("Tx", "Send ccnx packet to outgoing interface.", |
| MakeTraceSourceAccessor (&CcnxL3Protocol::m_txTrace)) |
| .AddTraceSource ("Rx", "Receive ccnx packet from incoming interface.", |
| MakeTraceSourceAccessor (&CcnxL3Protocol::m_rxTrace)) |
| .AddTraceSource ("Drop", "Drop ccnx packet", |
| MakeTraceSourceAccessor (&CcnxL3Protocol::m_dropTrace)) |
| .AddAttribute ("InterfaceList", "The set of Ccnx interfaces associated to this Ccnx stack.", |
| ObjectVectorValue (), |
| MakeObjectVectorAccessor (&CcnxL3Protocol::m_interfaces), |
| MakeObjectVectorChecker<CcnxInterface> ()) |
| |
| .AddTraceSource ("SendOutgoing", "A newly-generated packet by this node is about to be queued for transmission", |
| MakeTraceSourceAccessor (&CcnxL3Protocol::m_sendOutgoingTrace)) |
| |
| ; |
| return tid; |
| } |
| |
| CcnxL3Protocol::CcnxL3Protocol() |
| : m_identification (0) |
| { |
| NS_LOG_FUNCTION (this); |
| } |
| |
| CcnxL3Protocol::~CcnxL3Protocol () |
| { |
| NS_LOG_FUNCTION (this); |
| } |
| |
| void |
| CcnxL3Protocol::SetNode (Ptr<Node> node) |
| { |
| m_node = node; |
| // Add a LoopbackNetDevice if needed, and an CcnxInterface on top of it |
| SetupLoopback (); |
| } |
| |
| /* |
| * This method is called by AddAgregate and completes the aggregation |
| * by setting the node in the ccnx stack |
| */ |
| void |
| CcnxL3Protocol::NotifyNewAggregate () |
| { |
| if (m_node == 0) |
| { |
| Ptr<Node>node = this->GetObject<Node>(); |
| // verify that it's a valid node and that |
| // the node has not been set before |
| if (node != 0) |
| { |
| this->SetNode (node); |
| } |
| } |
| Object::NotifyNewAggregate (); |
| } |
| |
| // void |
| // CcnxL3Protocol::SetRoutingProtocol (Ptr<CcnxRoutingProtocol> routingProtocol) |
| // { |
| // NS_LOG_FUNCTION (this); |
| // m_routingProtocol = routingProtocol; |
| // m_routingProtocol->SetCcnx (this); |
| // } |
| |
| |
| // Ptr<CcnxRoutingProtocol> |
| // CcnxL3Protocol::GetRoutingProtocol (void) const |
| // { |
| // return m_routingProtocol; |
| // } |
| |
| void |
| CcnxL3Protocol::DoDispose (void) |
| { |
| NS_LOG_FUNCTION (this); |
| |
| for (CcnxInterfaceList::iterator i = m_interfaces.begin (); i != m_interfaces.end (); ++i) |
| { |
| *i = 0; |
| } |
| m_interfaces.clear (); |
| m_node = 0; |
| // m_routingProtocol = 0; |
| Object::DoDispose (); |
| } |
| |
| uint32_t |
| CcnxL3Protocol::AddInterface (Ptr<NetDevice> device) |
| { |
| NS_LOG_FUNCTION (this << &device); |
| |
| Ptr<Node> node = GetObject<Node> (); |
| node->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this), |
| CcnxL3Protocol::PROT_NUMBER, device, true); |
| |
| // ccnx doesn't need arp protocol to run. Everything is broadcast! |
| // node->RegisterProtocolHandler (MakeCallback (&ArpL3Protocol::Receive, PeekPointer (GetObject<ArpL3Protocol> ())), |
| // ArpL3Protocol::PROT_NUMBER, device, true); |
| |
| Ptr<CcnxInterface> interface = CreateObject<CcnxInterface> (); |
| interface->SetNode (m_node); |
| interface->SetDevice (device); |
| // interface->SetForwarding (m_ipForward); |
| return AddCcnxInterface (interface); |
| } |
| |
| uint32_t |
| CcnxL3Protocol::AddCcnxInterface (Ptr<CcnxInterface>interface) |
| { |
| NS_LOG_FUNCTION (this << interface); |
| uint32_t index = m_interfaces.size (); |
| m_interfaces.push_back (interface); |
| return index; |
| } |
| |
| Ptr<CcnxInterface> |
| CcnxL3Protocol::GetInterface (uint32_t index) const |
| { |
| if (index < m_interfaces.size ()) |
| { |
| return m_interfaces[index]; |
| } |
| return 0; |
| } |
| |
| uint32_t |
| CcnxL3Protocol::GetNInterfaces (void) const |
| { |
| return m_interfaces.size (); |
| } |
| |
| int32_t |
| CcnxL3Protocol::GetInterfaceForDevice ( |
| Ptr<const NetDevice> device) const |
| { |
| int32_t interface = 0; |
| for (CcnxInterfaceList::const_iterator i = m_interfaces.begin (); |
| i != m_interfaces.end (); |
| i++, interface++) |
| { |
| if ((*i)->GetDevice () == device) |
| { |
| return interface; |
| } |
| } |
| |
| return -1; |
| } |
| |
| void |
| CcnxL3Protocol::Receive ( Ptr<NetDevice> device, Ptr<const Packet> p, uint16_t protocol, const Address &from, |
| const Address &to, NetDevice::PacketType packetType) |
| { |
| NS_LOG_FUNCTION (this << &device << p << protocol << from); |
| |
| NS_LOG_LOGIC ("Packet from " << from << " received on node " << |
| m_node->GetId ()); |
| |
| uint32_t interface = 0; |
| Ptr<Packet> packet = p->Copy (); |
| |
| Ptr<CcnxInterface> ccnxInterface; |
| for (CcnxInterfaceList::const_iterator i = m_interfaces.begin (); |
| i != m_interfaces.end (); |
| i++, interface++) |
| { |
| ccnxInterface = *i; |
| if (ccnxInterface->GetDevice () == device) |
| { |
| if (ccnxInterface->IsUp ()) |
| { |
| m_rxTrace (packet, m_node->GetObject<Ccnx> (), interface); |
| break; |
| } |
| else |
| { |
| NS_LOG_LOGIC ("Dropping received packet -- interface is down"); |
| CcnxHeader ipHeader; |
| packet->RemoveHeader (ipHeader); |
| m_dropTrace (ipHeader, packet, DROP_INTERFACE_DOWN, m_node->GetObject<Ccnx> (), interface); |
| return; |
| } |
| } |
| } |
| |
| CcnxHeader ipHeader; |
| if (Node::ChecksumEnabled ()) |
| { |
| ipHeader.EnableChecksum (); |
| } |
| packet->RemoveHeader (ipHeader); |
| |
| // Trim any residual frame padding from underlying devices |
| if (ipHeader.GetPayloadSize () < packet->GetSize ()) |
| { |
| packet->RemoveAtEnd (packet->GetSize () - ipHeader.GetPayloadSize ()); |
| } |
| |
| if (!ipHeader.IsChecksumOk ()) |
| { |
| NS_LOG_LOGIC ("Dropping received packet -- checksum not ok"); |
| m_dropTrace (ipHeader, packet, DROP_BAD_CHECKSUM, m_node->GetObject<Ccnx> (), interface); |
| return; |
| } |
| |
| for (SocketList::iterator i = m_sockets.begin (); i != m_sockets.end (); ++i) |
| { |
| NS_LOG_LOGIC ("Forwarding to raw socket"); |
| Ptr<CcnxRawSocketImpl> socket = *i; |
| socket->ForwardUp (packet, ipHeader, ccnxInterface); |
| } |
| |
| NS_ASSERT_MSG (m_routingProtocol != 0, "Need a routing protocol object to process packets"); |
| if (!m_routingProtocol->RouteInput (packet, ipHeader, device, |
| MakeCallback (&CcnxL3Protocol::IpForward, this), |
| MakeCallback (&CcnxL3Protocol::IpMulticastForward, this), |
| MakeCallback (&CcnxL3Protocol::LocalDeliver, this), |
| MakeCallback (&CcnxL3Protocol::RouteInputError, this) |
| )) |
| { |
| NS_LOG_WARN ("No route found for forwarding packet. Drop."); |
| m_dropTrace (ipHeader, packet, DROP_NO_ROUTE, m_node->GetObject<Ccnx> (), interface); |
| } |
| |
| |
| } |
| |
| // void |
| // CcnxL3Protocol::SendWithHeader (Ptr<Packet> packet, |
| // CcnxHeader ipHeader, |
| // Ptr<CcnxRoute> route) |
| // { |
| // NS_LOG_FUNCTION (this << packet << ipHeader << route); |
| // SendRealOut (route, packet, ipHeader); |
| // } |
| |
| void |
| CcnxL3Protocol::Send (Ptr<Packet> packet, |
| Ptr<CcnxRoute> route) |
| { |
| NS_LOG_FUNCTION (this << packet << route); |
| |
| // CcnxHeader ipHeader; |
| // bool mayFragment = true; |
| // uint8_t ttl = m_defaultTtl; |
| // SocketIpTtlTag tag; |
| // bool found = packet->RemovePacketTag (tag); |
| // if (found) |
| // { |
| // ttl = tag.GetTtl (); |
| // } |
| |
| // // Handle a few cases: |
| // // 1) packet is destined to limited broadcast address |
| // // 2) packet is destined to a subnet-directed broadcast address |
| // // 3) packet is not broadcast, and is passed in with a route entry |
| // // 4) packet is not broadcast, and is passed in with a route entry but route->GetGateway is not set (e.g., on-demand) |
| // // 5) packet is not broadcast, and route is NULL (e.g., a raw socket call, or ICMP) |
| |
| // // 1) packet is destined to limited broadcast address or link-local multicast address |
| // if (destination.IsBroadcast () || destination.IsLocalMulticast ()) |
| // { |
| // NS_LOG_LOGIC ("CcnxL3Protocol::Send case 1: limited broadcast"); |
| // ipHeader = BuildHeader (source, destination, protocol, packet->GetSize (), ttl, mayFragment); |
| // uint32_t ifaceIndex = 0; |
| // for (CcnxInterfaceList::iterator ifaceIter = m_interfaces.begin (); |
| // ifaceIter != m_interfaces.end (); ifaceIter++, ifaceIndex++) |
| // { |
| // Ptr<CcnxInterface> outInterface = *ifaceIter; |
| // Ptr<Packet> packetCopy = packet->Copy (); |
| |
| // NS_ASSERT (packetCopy->GetSize () <= outInterface->GetDevice ()->GetMtu ()); |
| |
| // m_sendOutgoingTrace (ipHeader, packetCopy, ifaceIndex); |
| // packetCopy->AddHeader (ipHeader); |
| // m_txTrace (packetCopy, m_node->GetObject<Ccnx> (), ifaceIndex); |
| // outInterface->Send (packetCopy, destination); |
| // } |
| // return; |
| // } |
| |
| // // 2) check: packet is destined to a subnet-directed broadcast address |
| // uint32_t ifaceIndex = 0; |
| // for (CcnxInterfaceList::iterator ifaceIter = m_interfaces.begin (); |
| // ifaceIter != m_interfaces.end (); ifaceIter++, ifaceIndex++) |
| // { |
| // Ptr<CcnxInterface> outInterface = *ifaceIter; |
| // for (uint32_t j = 0; j < GetNAddresses (ifaceIndex); j++) |
| // { |
| // CcnxInterfaceAddress ifAddr = GetAddress (ifaceIndex, j); |
| // NS_LOG_LOGIC ("Testing address " << ifAddr.GetLocal () << " with mask " << ifAddr.GetMask ()); |
| // if (destination.IsSubnetDirectedBroadcast (ifAddr.GetMask ()) && |
| // destination.CombineMask (ifAddr.GetMask ()) == ifAddr.GetLocal ().CombineMask (ifAddr.GetMask ()) ) |
| // { |
| // NS_LOG_LOGIC ("CcnxL3Protocol::Send case 2: subnet directed bcast to " << ifAddr.GetLocal ()); |
| // ipHeader = BuildHeader (source, destination, protocol, packet->GetSize (), ttl, mayFragment); |
| // Ptr<Packet> packetCopy = packet->Copy (); |
| // m_sendOutgoingTrace (ipHeader, packetCopy, ifaceIndex); |
| // packetCopy->AddHeader (ipHeader); |
| // m_txTrace (packetCopy, m_node->GetObject<Ccnx> (), ifaceIndex); |
| // outInterface->Send (packetCopy, destination); |
| // return; |
| // } |
| // } |
| // } |
| |
| // // 3) packet is not broadcast, and is passed in with a route entry |
| // // with a valid CcnxAddress as the gateway |
| // if (route && route->GetGateway () != CcnxAddress ()) |
| // { |
| // NS_LOG_LOGIC ("CcnxL3Protocol::Send case 3: passed in with route"); |
| // ipHeader = BuildHeader (source, destination, protocol, packet->GetSize (), ttl, mayFragment); |
| // int32_t interface = GetInterfaceForDevice (route->GetOutputDevice ()); |
| // m_sendOutgoingTrace (ipHeader, packet, interface); |
| // SendRealOut (route, packet->Copy (), ipHeader); |
| // return; |
| // } |
| // // 4) packet is not broadcast, and is passed in with a route entry but route->GetGateway is not set (e.g., on-demand) |
| // if (route && route->GetGateway () == CcnxAddress ()) |
| // { |
| // // This could arise because the synchronous RouteOutput() call |
| // // returned to the transport protocol with a source address but |
| // // there was no next hop available yet (since a route may need |
| // // to be queried). |
| // NS_FATAL_ERROR ("CcnxL3Protocol::Send case 4: This case not yet implemented"); |
| // } |
| // // 5) packet is not broadcast, and route is NULL (e.g., a raw socket call) |
| // NS_LOG_LOGIC ("CcnxL3Protocol::Send case 5: passed in with no route " << destination); |
| // Socket::SocketErrno errno_; |
| // Ptr<NetDevice> oif (0); // unused for now |
| // ipHeader = BuildHeader (source, destination, protocol, packet->GetSize (), ttl, mayFragment); |
| // Ptr<CcnxRoute> newRoute; |
| // if (m_routingProtocol != 0) |
| // { |
| // newRoute = m_routingProtocol->RouteOutput (packet, ipHeader, oif, errno_); |
| // } |
| // else |
| // { |
| // NS_LOG_ERROR ("CcnxL3Protocol::Send: m_routingProtocol == 0"); |
| // } |
| // if (newRoute) |
| // { |
| // int32_t interface = GetInterfaceForDevice (newRoute->GetOutputDevice ()); |
| // m_sendOutgoingTrace (ipHeader, packet, interface); |
| // SendRealOut (newRoute, packet->Copy (), ipHeader); |
| // } |
| // else |
| // { |
| // NS_LOG_WARN ("No route to host. Drop."); |
| // m_dropTrace (ipHeader, packet, DROP_NO_ROUTE, m_node->GetObject<Ccnx> (), 0); |
| // } |
| } |
| |
| |
| void |
| CcnxL3Protocol::SendRealOut (Ptr<CcnxRoute> route, |
| Ptr<Packet> packet, |
| CcnxHeader const &ipHeader) |
| { |
| NS_LOG_FUNCTION (this << packet << &ipHeader); |
| |
| // if (route == 0) |
| // { |
| // NS_LOG_WARN ("No route to host. Drop."); |
| // m_dropTrace (ipHeader, packet, DROP_NO_ROUTE, m_node->GetObject<Ccnx> (), 0); |
| // return; |
| // } |
| // packet->AddHeader (ipHeader); |
| // Ptr<NetDevice> outDev = route->GetOutputDevice (); |
| // int32_t interface = GetInterfaceForDevice (outDev); |
| // NS_ASSERT (interface >= 0); |
| // Ptr<CcnxInterface> outInterface = GetInterface (interface); |
| // NS_LOG_LOGIC ("Send via NetDevice ifIndex " << outDev->GetIfIndex () << " ccnxInterfaceIndex " << interface); |
| |
| // NS_ASSERT_MSG (packet->GetSize () <= outInterface->GetDevice ()->GetMtu (), |
| // "Packet size " << packet->GetSize () << " exceeds device MTU " |
| // << outInterface->GetDevice ()->GetMtu () |
| // << " for Ccnx; fragmentation not supported"); |
| // if (!route->GetGateway ().IsEqual (CcnxAddress ("0.0.0.0"))) |
| // { |
| // if (outInterface->IsUp ()) |
| // { |
| // NS_LOG_LOGIC ("Send to gateway " << route->GetGateway ()); |
| // m_txTrace (packet, m_node->GetObject<Ccnx> (), interface); |
| // outInterface->Send (packet, route->GetGateway ()); |
| // } |
| // else |
| // { |
| // NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << route->GetGateway ()); |
| // CcnxHeader ipHeader; |
| // packet->RemoveHeader (ipHeader); |
| // m_dropTrace (ipHeader, packet, DROP_INTERFACE_DOWN, m_node->GetObject<Ccnx> (), interface); |
| // } |
| // } |
| // else |
| // { |
| // if (outInterface->IsUp ()) |
| // { |
| // NS_LOG_LOGIC ("Send to destination " << ipHeader.GetDestination ()); |
| // m_txTrace (packet, m_node->GetObject<Ccnx> (), interface); |
| // outInterface->Send (packet, ipHeader.GetDestination ()); |
| // } |
| // else |
| // { |
| // NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << ipHeader.GetDestination ()); |
| // CcnxHeader ipHeader; |
| // packet->RemoveHeader (ipHeader); |
| // m_dropTrace (ipHeader, packet, DROP_INTERFACE_DOWN, m_node->GetObject<Ccnx> (), interface); |
| // } |
| // } |
| } |
| |
| |
| // This function analogous to Linux ip_forward() |
| // void |
| // CcnxL3Protocol::IpForward (Ptr<CcnxRoute> rtentry, Ptr<const Packet> p, const CcnxHeader &header) |
| // { |
| // NS_LOG_FUNCTION (this << rtentry << p << header); |
| // NS_LOG_LOGIC ("Forwarding logic for node: " << m_node->GetId ()); |
| // // Forwarding |
| // CcnxHeader ipHeader = header; |
| // Ptr<Packet> packet = p->Copy (); |
| // int32_t interface = GetInterfaceForDevice (rtentry->GetOutputDevice ()); |
| // ipHeader.SetTtl (ipHeader.GetTtl () - 1); |
| // if (ipHeader.GetTtl () == 0) |
| // { |
| // // Do not reply to ICMP or to multicast/broadcast IP address |
| // if (ipHeader.GetProtocol () != Icmpv4L4Protocol::PROT_NUMBER && |
| // ipHeader.GetDestination ().IsBroadcast () == false && |
| // ipHeader.GetDestination ().IsMulticast () == false) |
| // { |
| // Ptr<Icmpv4L4Protocol> icmp = GetIcmp (); |
| // icmp->SendTimeExceededTtl (ipHeader, packet); |
| // } |
| // NS_LOG_WARN ("TTL exceeded. Drop."); |
| // m_dropTrace (header, packet, DROP_TTL_EXPIRED, m_node->GetObject<Ccnx> (), interface); |
| // return; |
| // } |
| // m_unicastForwardTrace (ipHeader, packet, interface); |
| // SendRealOut (rtentry, packet, ipHeader); |
| // } |
| |
| // Will be called from CcnxRoutingProtocol if prefix is locally registered |
| // Local interest will be satisfied inside CcnxInterface::Send call |
| |
| void |
| CcnxL3Protocol::LocalDeliver (Ptr<const Packet> packet, CcnxHeader const&ip, uint32_t iif) |
| { |
| NS_LOG_FUNCTION (this << packet << &ip); |
| Ptr<Packet> p = packet->Copy (); // need to pass a non-const packet up |
| |
| // m_localDeliverTrace (ip, packet, iif); |
| |
| // Ptr<CcnxL4Protocol> protocol = GetProtocol (ip.GetProtocol ()); |
| // if (protocol != 0) |
| // { |
| // // we need to make a copy in the unlikely event we hit the |
| // // RX_ENDPOINT_UNREACH codepath |
| // Ptr<Packet> copy = p->Copy (); |
| // enum CcnxL4Protocol::RxStatus status = |
| // protocol->Receive (p, ip, GetInterface (iif)); |
| // switch (status) { |
| // case CcnxL4Protocol::RX_OK: |
| // // fall through |
| // case CcnxL4Protocol::RX_ENDPOINT_CLOSED: |
| // // fall through |
| // case CcnxL4Protocol::RX_CSUM_FAILED: |
| // break; |
| // case CcnxL4Protocol::RX_ENDPOINT_UNREACH: |
| // if (ip.GetDestination ().IsBroadcast () == true || |
| // ip.GetDestination ().IsMulticast () == true) |
| // { |
| // break; // Do not reply to broadcast or multicast |
| // } |
| // // Another case to suppress ICMP is a subnet-directed broadcast |
| // bool subnetDirected = false; |
| // for (uint32_t i = 0; i < GetNAddresses (iif); i++) |
| // { |
| // CcnxInterfaceAddress addr = GetAddress (iif, i); |
| // if (addr.GetLocal ().CombineMask (addr.GetMask ()) == ip.GetDestination ().CombineMask (addr.GetMask ()) && |
| // ip.GetDestination ().IsSubnetDirectedBroadcast (addr.GetMask ())) |
| // { |
| // subnetDirected = true; |
| // } |
| s// } |
| // if (subnetDirected == false) |
| // { |
| // GetIcmp ()->SendDestUnreachPort (ip, copy); |
| // } |
| // } |
| // } |
| } |
| |
| void |
| CcnxL3Protocol::SetMetric (uint32_t i, uint16_t metric) |
| { |
| NS_LOG_FUNCTION (this << i << metric); |
| Ptr<CcnxInterface> interface = GetInterface (i); |
| interface->SetMetric (metric); |
| } |
| |
| uint16_t |
| CcnxL3Protocol::GetMetric (uint32_t i) const |
| { |
| Ptr<CcnxInterface> interface = GetInterface (i); |
| return interface->GetMetric (); |
| } |
| |
| uint16_t |
| CcnxL3Protocol::GetMtu (uint32_t i) const |
| { |
| Ptr<CcnxInterface> interface = GetInterface (i); |
| return interface->GetDevice ()->GetMtu (); |
| } |
| |
| bool |
| CcnxL3Protocol::IsUp (uint32_t i) const |
| { |
| Ptr<CcnxInterface> interface = GetInterface (i); |
| return interface->IsUp (); |
| } |
| |
| void |
| CcnxL3Protocol::SetUp (uint32_t i) |
| { |
| NS_LOG_FUNCTION (this << i); |
| Ptr<CcnxInterface> interface = GetInterface (i); |
| interface->SetUp (); |
| |
| if (m_routingProtocol != 0) |
| { |
| m_routingProtocol->NotifyInterfaceUp (i); |
| } |
| } |
| |
| void |
| CcnxL3Protocol::SetDown (uint32_t ifaceIndex) |
| { |
| NS_LOG_FUNCTION (this << ifaceIndex); |
| Ptr<CcnxInterface> interface = GetInterface (ifaceIndex); |
| interface->SetDown (); |
| |
| if (m_routingProtocol != 0) |
| { |
| m_routingProtocol->NotifyInterfaceDown (ifaceIndex); |
| } |
| } |
| |
| Ptr<NetDevice> |
| CcnxL3Protocol::GetNetDevice (uint32_t i) |
| { |
| return GetInterface (i)->GetDevice (); |
| } |
| |
| void |
| CcnxL3Protocol::RouteInputError (Ptr<const Packet> p, const CcnxHeader & ipHeader, Socket::SocketErrno sockErrno) |
| { |
| NS_LOG_FUNCTION (this << p << ipHeader << sockErrno); |
| NS_LOG_LOGIC ("Route input failure-- dropping packet to " << ipHeader << " with errno " << sockErrno); |
| m_dropTrace (ipHeader, p, DROP_ROUTE_ERROR, m_node->GetObject<Ccnx> (), 0); |
| } |
| |
| } //namespace ns3 |