Adding more components to CCNx stack
diff --git a/model/ccnx-interface.cc b/model/ccnx-face.cc
similarity index 61%
rename from model/ccnx-interface.cc
rename to model/ccnx-face.cc
index aca2dcd..27483b0 100644
--- a/model/ccnx-interface.cc
+++ b/model/ccnx-face.cc
@@ -19,7 +19,7 @@
*
*/
-#include "ccnx-interface.h"
+#include "ccnx-face.h"
#include "ns3/ccnx-address.h"
#include "ns3/ccnx-l3-protocol.h"
@@ -29,27 +29,27 @@
#include "ns3/node.h"
#include "ns3/pointer.h"
-NS_LOG_COMPONENT_DEFINE ("CcnxInterface");
+NS_LOG_COMPONENT_DEFINE ("CcnxFace");
namespace ns3 {
-NS_OBJECT_ENSURE_REGISTERED (CcnxInterface);
+NS_OBJECT_ENSURE_REGISTERED (CcnxFace);
TypeId
-CcnxInterface::GetTypeId (void)
+CcnxFace::GetTypeId (void)
{
- static TypeId tid = TypeId ("ns3::CcnxInterface")
+ static TypeId tid = TypeId ("ns3::CcnxFace")
.SetParent<Object> ()
;
return tid;
}
/**
- * By default, Ccnx interface are created in the "down" state
+ * By default, Ccnx face are created in the "down" state
* with no IP addresses. Before becoming useable, the user must
* invoke SetUp on them once an Ccnx address and mask have been set.
*/
-CcnxInterface::CcnxInterface ()
+CcnxFace::CcnxFace ()
: m_ifup (false),
m_metric (1),
m_node (0),
@@ -58,13 +58,13 @@
NS_LOG_FUNCTION (this);
}
-CcnxInterface::~CcnxInterface ()
+CcnxFace::~CcnxFace ()
{
NS_LOG_FUNCTION_NOARGS ();
}
void
-CcnxInterface::DoDispose (void)
+CcnxFace::DoDispose (void)
{
NS_LOG_FUNCTION_NOARGS ();
m_node = 0;
@@ -73,93 +73,93 @@
}
void
-CcnxInterface::SetNode (Ptr<Node> node)
+CcnxFace::SetNode (Ptr<Node> node)
{
m_node = node;
}
void
-CcnxInterface::SetDevice (Ptr<NetDevice> device)
+CcnxFace::SetDevice (Ptr<NetDevice> device)
{
m_device = device;
}
Ptr<NetDevice>
-CcnxInterface::GetDevice (void) const
+CcnxFace::GetDevice (void) const
{
return m_device;
}
void
-CcnxInterface::SetMetric (uint16_t metric)
+CcnxFace::SetMetric (uint16_t metric)
{
NS_LOG_FUNCTION (metric);
m_metric = metric;
}
uint16_t
-CcnxInterface::GetMetric (void) const
+CcnxFace::GetMetric (void) const
{
NS_LOG_FUNCTION_NOARGS ();
return m_metric;
}
/**
- * These are interface states and may be distinct from
+ * These are face states and may be distinct from
* NetDevice states, such as found in real implementations
- * (where the device may be down but interface state is still up).
+ * (where the device may be down but face state is still up).
*/
bool
-CcnxInterface::IsUp (void) const
+CcnxFace::IsUp (void) const
{
NS_LOG_FUNCTION_NOARGS ();
return m_ifup;
}
bool
-CcnxInterface::IsDown (void) const
+CcnxFace::IsDown (void) const
{
NS_LOG_FUNCTION_NOARGS ();
return !m_ifup;
}
void
-CcnxInterface::SetUp (void)
+CcnxFace::SetUp (void)
{
NS_LOG_FUNCTION_NOARGS ();
m_ifup = true;
}
void
-CcnxInterface::SetDown (void)
+CcnxFace::SetDown (void)
{
NS_LOG_FUNCTION_NOARGS ();
m_ifup = false;
}
void
-CcnxInterface::Send (Ptr<Packet> p)
+CcnxFace::Send (Ptr<Packet> packet)
{
- NS_LOG_FUNCTION (*p);
+ NS_ASSERT_MSG (packet->GetSize () <= GetDevice ()->GetMtu (),
+ "Packet size " << packet->GetSize () << " exceeds device MTU "
+ << GetDevice ()->GetMtu ()
+ << " for Ccnx; fragmentation not supported");
+
+ NS_LOG_FUNCTION (*packet);
if (!IsUp ())
{
return;
}
- // Check if Local Delivery
- // if (DynamicCast<LoopbackNetDevice> (m_device))
- // {
- // // XXX additional checks needed here (such as whether multicast
- // // goes to loopback)?
- // m_device->Send (p, m_device->GetBroadcast (),
- // CcnxL3Protocol::PROT_NUMBER);
- // return;
- // }
-
- NS_LOG_LOGIC ("Doesn't need ARP");
- m_device->Send (p, m_device->GetBroadcast (),
+ m_device->Send (packet, m_device->GetBroadcast (),
CcnxL3Protocol::PROT_NUMBER);
}
+std::ostream& operator<< (std::ostream& os, CcnxFace const& face)
+{
+ os << "dev=" << face.GetDevice ()->GetIfIndex ();
+ return os;
+}
+
}; // namespace ns3
diff --git a/model/ccnx-interface.h b/model/ccnx-face.h
similarity index 62%
rename from model/ccnx-interface.h
rename to model/ccnx-face.h
index f82c3d5..769f938 100644
--- a/model/ccnx-interface.h
+++ b/model/ccnx-face.h
@@ -17,10 +17,12 @@
*
* Authors:
*/
-#ifndef CCNX_INTERFACE_H
-#define CCNX_INTERFACE_H
+#ifndef CCNX_FACE_H
+#define CCNX_FACE_H
#include <list>
+#include <ostream>
+
#include "ns3/ptr.h"
#include "ns3/object.h"
@@ -31,79 +33,79 @@
class Node;
/**
- * \brief The Ccnx representation of a network interface
+ * \brief The Ccnx representation of a network face
*
* This class roughly corresponds to the struct in_device
* of Linux; the main purpose is to provide address-family
- * specific information (addresses) about an interface.
+ * specific information (addresses) about an face.
*
- * By default, Ccnx interface are created in the "down" state
+ * By default, Ccnx face are created in the "down" state
* no IP addresses. Before becoming useable, the user must
* add an address of some type and invoke Setup on them.
*/
-class CcnxInterface : public Object
+class CcnxFace : public Object
{
public:
static TypeId GetTypeId (void);
- CcnxInterface ();
- virtual ~CcnxInterface();
+ CcnxFace ();
+ virtual ~CcnxFace();
- void SetNode (Ptr<Node> node);
- void SetDevice (Ptr<NetDevice> device);
+ virtual void SetNode (Ptr<Node> node);
+ virtual void SetDevice (Ptr<NetDevice> device);
/**
* \returns the underlying NetDevice. This method cannot return zero.
*/
- Ptr<NetDevice> GetDevice (void) const;
+ virtual Ptr<NetDevice> GetDevice (void) const;
/**
- * \param metric configured routing metric (cost) of this interface
+ * \param metric configured routing metric (cost) of this face
*
* Note: This is synonymous to the Metric value that ifconfig prints
* out. It is used by ns-3 global routing, but other routing daemons
* choose to ignore it.
*/
- void SetMetric (uint16_t metric);
+ virtual void SetMetric (uint16_t metric);
/**
- * \returns configured routing metric (cost) of this interface
+ * \returns configured routing metric (cost) of this face
*
* Note: This is synonymous to the Metric value that ifconfig prints
* out. It is used by ns-3 global routing, but other routing daemons
* may choose to ignore it.
*/
- uint16_t GetMetric (void) const;
+ virtual uint16_t GetMetric (void) const;
/**
- * These are IP interface states and may be distinct from
+ * These are IP face states and may be distinct from
* NetDevice states, such as found in real implementations
- * (where the device may be down but IP interface state is still up).
+ * (where the device may be down but IP face state is still up).
*/
/**
- * \returns true if this interface is enabled, false otherwise.
+ * \returns true if this face is enabled, false otherwise.
*/
- bool IsUp (void) const;
+ virtual bool IsUp (void) const;
/**
- * \returns true if this interface is disabled, false otherwise.
+ * \returns true if this face is disabled, false otherwise.
*/
- bool IsDown (void) const;
+ virtual bool IsDown (void) const;
/**
- * Enable this interface
+ * Enable this face
*/
- void SetUp (void);
+ virtual void SetUp (void);
/**
- * Disable this interface
+ * Disable this face
*/
- void SetDown (void);
+ virtual void SetDown (void);
/**
* \param p packet to send
*/
- void Send (Ptr<Packet> p);
+ virtual void Send (Ptr<Packet> p);
protected:
virtual void DoDispose (void);
@@ -115,6 +117,8 @@
Ptr<NetDevice> m_device;
};
+std::ostream& operator<< (std::ostream& os, CcnxFace const& face);
+
} // namespace ns3
-#endif
+#endif //CCNX_FACE_H
diff --git a/model/ccnx-forwarding-protocol.cc b/model/ccnx-forwarding-protocol.cc
new file mode 100644
index 0000000..b7e5a11
--- /dev/null
+++ b/model/ccnx-forwarding-protocol.cc
@@ -0,0 +1,42 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 University of Washington
+ *
+ * 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
+ */
+
+#include "ns3/assert.h"
+
+#include "ccnx-route.h"
+#include "ccnx-forwarding-protocol.h"
+
+namespace ns3 {
+
+NS_OBJECT_ENSURE_REGISTERED (CcnxForwardingProtocol);
+
+TypeId CcnxForwardingProtocol::GetTypeId (void)
+{
+ static TypeId tid = TypeId ("ns3::CcnxForwardingProtocol")
+ .SetParent<Object> ()
+ ;
+ return tid;
+}
+
+void
+CcnxForwardingProtocol::SetCcnx (Ptr<Ccnx> ccnx)
+{
+ m_ccnx = ccnx;
+}
+
+} //namespace ns3
diff --git a/model/ccnx-forwarding-protocol.h b/model/ccnx-forwarding-protocol.h
new file mode 100644
index 0000000..e6d2586
--- /dev/null
+++ b/model/ccnx-forwarding-protocol.h
@@ -0,0 +1,144 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 University of Washington
+ *
+ * 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
+ */
+#ifndef CCNX_FORWARDING_PROTOCOL_H
+#define CCNX_FORWARDING_PROTOCOL_H
+
+#include "ns3/packet.h"
+#include "ns3/callback.h"
+#include "ns3/object.h"
+#include "ns3/socket.h"
+#include "ccnx-header.h"
+#include "ns3/ccnx-interface-address.h"
+#include "ccnx.h"
+#include "ns3/output-stream-wrapper.h"
+
+namespace ns3 {
+
+class CcnxRoute;
+class CcnxFace;
+
+/**
+ * \ingroup internet
+ * \defgroup ccnxForwarding CcnxForwardingProtocol
+ */
+/**
+ * \ingroup ccnxForwarding
+ * \brief Abstract base class for Ccnx forwarding protocols.
+ *
+ * Defines two virtual functions for packet forwarding and forwarding. The first,
+ * RouteOutput(), is used for locally originated packets, and the second,
+ * RouteInput(), is used for forwarding and/or delivering received packets.
+ * Also defines the signatures of four callbacks used in RouteInput().
+ *
+ */
+class CcnxForwardingProtocol : public Object
+{
+public:
+ static TypeId GetTypeId (void);
+
+ typedef Callback<void, Ptr<const Packet>, Ptr<CcnxRoute> > SendCallback;
+ typedef Callback<void, Ptr<const Packet>, Socket::SocketErrno > ErrorCallback;
+
+ /**
+ * \brief Query forwarding cache for an existing route, for an outbound packet
+ // *
+ // * This lookup is used by transport protocols. It does not cause any
+ // * packet to be forwarded, and is synchronous. Can be used for
+ // * multicast or unicast. The Linux equivalent is ip_route_output()
+ // *
+ // * \param p packet to be routed. Note that this method may modify the packet.
+ // * Callers may also pass in a null pointer.
+ // * \param header input parameter (used to form key to search for the route)
+ // * \param oif Output interface Netdevice. May be zero, or may be bound via
+ // * socket options to a particular output interface.
+ // * \param sockerr Output parameter; socket errno
+ // *
+ // * \returns a code that indicates what happened in the lookup
+ // */
+ // virtual Ptr<CcnxRoute> RouteOutput (Ptr<Packet> p, const CcnxHeader &header, Ptr<NetDevice> oif, Socket::SocketErrno &sockerr) = 0;
+
+ /**
+ * \brief Route an input packet (to be forwarded or locally delivered)
+ *
+ * This lookup is used in the forwarding process. The packet is
+ * handed over to the CcnxForwardingProtocol, and will get forwarded onward
+ * by one of the callbacks. The Linux equivalent is ip_route_input().
+ * There are four valid outcomes, and a matching callbacks to handle each.
+ *
+ * \param p received packet
+ * \param header input parameter used to form a search key for a route
+ * \param iface Pointer to ingress face
+ * \param ucb Callback for the case in which the packet is to be forwarded
+ * \param ecb Callback to call if there is an error in forwarding
+ * \returns true if the CcnxForwardingProtocol takes responsibility for
+ * forwarding or delivering the packet, false otherwise
+ */
+ virtual bool RouteInput (Ptr<const Packet> p, Ptr<const CcnxFace> iface,
+ SendCallback ucb, ErrorCallback ecb) = 0;
+
+ /**
+ * \param interface the index of the interface we are being notified about
+ *
+ * Protocols are expected to implement this method to be notified of the state change of
+ * an interface in a node.
+ */
+ virtual void NotifyInterfaceUp (uint32_t interface) = 0;
+ /**
+ * \param interface the index of the interface we are being notified about
+ *
+ * Protocols are expected to implement this method to be notified of the state change of
+ * an interface in a node.
+ */
+ virtual void NotifyInterfaceDown (uint32_t interface) = 0;
+
+ /**
+ * \param interface the index of the interface we are being notified about
+ * \param address a new address being added to an interface
+ *
+ * Protocols are expected to implement this method to be notified whenever
+ * a new address is added to an interface. Typically used to add a 'network route' on an
+ * interface. Can be invoked on an up or down interface.
+ */
+ virtual void NotifyAddAddress (uint32_t interface, CcnxInterfaceAddress address) = 0;
+
+ /**
+ * \param interface the index of the interface we are being notified about
+ * \param address a new address being added to an interface
+ *
+ * Protocols are expected to implement this method to be notified whenever
+ * a new address is removed from an interface. Typically used to remove the 'network route' of an
+ * interface. Can be invoked on an up or down interface.
+ */
+ virtual void NotifyRemoveAddress (uint32_t interface, CcnxInterfaceAddress address) = 0;
+
+ /**
+ * \param ccnx the ccnx object this forwarding protocol is being associated with
+ *
+ * Typically, invoked directly or indirectly from ns3::Ccnx::SetForwardingProtocol
+ */
+ virtual void SetCcnx (Ptr<Ccnx> ccnx);
+
+ virtual void PrintForwardingTable (Ptr<OutputStreamWrapper> stream) const = 0;
+
+protected:
+ Ptr<Ccnx> m_ccnx;
+};
+
+} //namespace ns3
+
+#endif /* CCNX_FORWARDING_PROTOCOL_H */
diff --git a/model/ccnx-l3-protocol.cc b/model/ccnx-l3-protocol.cc
index bf1230c..bbb5853 100644
--- a/model/ccnx-l3-protocol.cc
+++ b/model/ccnx-l3-protocol.cc
@@ -15,7 +15,7 @@
// 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>
+// Author:
//
#include "ns3/packet.h"
@@ -24,16 +24,13 @@
#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"
@@ -70,7 +67,6 @@
}
CcnxL3Protocol::CcnxL3Protocol()
- : m_identification (0)
{
NS_LOG_FUNCTION (this);
}
@@ -84,8 +80,6 @@
CcnxL3Protocol::SetNode (Ptr<Node> node)
{
m_node = node;
- // Add a LoopbackNetDevice if needed, and an CcnxInterface on top of it
- SetupLoopback ();
}
/*
@@ -108,443 +102,156 @@
Object::NotifyNewAggregate ();
}
-// void
-// CcnxL3Protocol::SetRoutingProtocol (Ptr<CcnxRoutingProtocol> routingProtocol)
-// {
-// NS_LOG_FUNCTION (this);
-// m_routingProtocol = routingProtocol;
-// m_routingProtocol->SetCcnx (this);
-// }
+void
+CcnxL3Protocol::SetForwardingProtocol (Ptr<CcnxForwardingProtocol> forwardingProtocol)
+{
+ NS_LOG_FUNCTION (this);
+ m_forwardingProtocol = forwardingProtocol;
+ m_forwardingProtocol->SetCcnx (this);
+}
-
-// Ptr<CcnxRoutingProtocol>
-// CcnxL3Protocol::GetRoutingProtocol (void) const
-// {
-// return m_routingProtocol;
-// }
+Ptr<CcnxForwardingProtocol>
+CcnxL3Protocol::GetForwardingProtocol (void) const
+{
+ return m_forwardingProtocol;
+}
void
CcnxL3Protocol::DoDispose (void)
{
NS_LOG_FUNCTION (this);
- for (CcnxInterfaceList::iterator i = m_interfaces.begin (); i != m_interfaces.end (); ++i)
+ for (CcnxInterfaceList::iterator i = m_faces.begin (); i != m_faces.end (); ++i)
{
*i = 0;
}
- m_interfaces.clear ();
+ m_faces.clear ();
m_node = 0;
- // m_routingProtocol = 0;
+ // m_forwardingProtocol = 0;
Object::DoDispose ();
}
uint32_t
-CcnxL3Protocol::AddInterface (Ptr<NetDevice> device)
+CcnxL3Protocol::AddFace (Ptr<CcnxFace> face)
{
- NS_LOG_FUNCTION (this << &device);
+ NS_LOG_FUNCTION (this << *face);
- Ptr<Node> node = GetObject<Node> ();
- node->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this),
- CcnxL3Protocol::PROT_NUMBER, device, true);
+ // Ptr<Node> node = GetObject<Node> (); ///< \todo not sure why this thing should be called...
+ face->setNode (m_node);
- // ccnx doesn't need arp protocol to run. Everything is broadcast!
- // node->RegisterProtocolHandler (MakeCallback (&ArpL3Protocol::Receive, PeekPointer (GetObject<ArpL3Protocol> ())),
- // ArpL3Protocol::PROT_NUMBER, device, true);
+ if (face->GetDevice() != 0)
+ {
+ m_node->RegisterProtocolHandler (MakeCallback (&CcnxL3Protocol::Receive, this),
+ CcnxL3Protocol::PROT_NUMBER, face->GetDevice(), true/*promiscuous mode*/);
+ }
- 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);
+ uint32_t index = m_faces.size ();
+ m_faces.push_back (interface);
return index;
}
+
Ptr<CcnxInterface>
-CcnxL3Protocol::GetInterface (uint32_t index) const
+CcnxL3Protocol::GetFace (uint32_t index) const
{
- if (index < m_interfaces.size ())
+ if (index < m_faces.size ())
{
- return m_interfaces[index];
+ return m_faces[index];
}
return 0;
}
uint32_t
-CcnxL3Protocol::GetNInterfaces (void) const
+CcnxL3Protocol::GetNFaces (void) const
{
- return m_interfaces.size ();
+ return m_faces.size ();
}
-int32_t
-CcnxL3Protocol::GetInterfaceForDevice (
- Ptr<const NetDevice> device) const
+Ptr<CcnxFace>
+GetFaceForDevice (Ptr<const NetDevice> device) const
{
- int32_t interface = 0;
- for (CcnxInterfaceList::const_iterator i = m_interfaces.begin ();
- i != m_interfaces.end ();
- i++, interface++)
+ for (CcnxInterfaceList::const_iterator i = m_faces.begin ();
+ i != m_faces.end ();
+ i++, face++)
{
if ((*i)->GetDevice () == device)
{
- return interface;
+ return *i;
}
}
- return -1;
+ NS_ASSERT_MSG (false "Should never get to this place" );
+ return 0;
}
+// Callback from lower layer
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 ());
+ 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;
- }
- }
- }
+ Ptr<CcnxFace> ccnxFace = GetFaceFromDevice (device);
- CcnxHeader ipHeader;
- if (Node::ChecksumEnabled ())
- {
- ipHeader.EnableChecksum ();
- }
- packet->RemoveHeader (ipHeader);
+ Receive (ccnxFace, p);
+}
- // Trim any residual frame padding from underlying devices
- if (ipHeader.GetPayloadSize () < packet->GetSize ())
+// Callback from higher level
+void Receive (Ptr<CcnxFace> incomingFace, Ptr<const Packet> p)
+{
+ if ( incomingFace->IsUp ())
{
- 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);
+ NS_LOG_LOGIC ("Dropping received packet -- interface is down");
+ m_dropTrace (packet, DROP_INTERFACE_DOWN, m_node->GetObject<Ccnx> (), incomingFace);
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);
- }
+
+ m_rxTrace (packet, m_node->GetObject<Ccnx> (), incomingFace);
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),
+ if (!m_routingProtocol->RouteInput (packet, incomingFace,
+ MakeCallback (&CcnxL3Protocol::Send, 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);
+ m_dropTrace (packet, DROP_NO_ROUTE, m_node->GetObject<Ccnx> (), incomingFace);
}
-
-
-}
-
-// 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)
+CcnxL3Protocol::Send (Ptr<Packet> packet, Ptr<CcnxRoute> route)
{
- NS_LOG_FUNCTION (this << packet << &ipHeader);
+ NS_LOG_FUNCTION (this << "packet: " << packet << ", route: "<< route);
- // 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);
+ if (route == 0)
+ {
+ NS_LOG_WARN ("No route to host. Drop.");
+ m_dropTrace (ipHeader, packet, DROP_NO_ROUTE, m_node->GetObject<Ccnx> (), 0);
+ return;
+ }
+ Ptr<CcnxFace> outFace = route->GetOutputFace ();
- // 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);
- // }
- // }
+ if (outFace->IsUp ())
+ {
+ NS_LOG_LOGIC ("Sending via face " << *outFace);
+ m_txTrace (packet, m_node->GetObject<Ccnx> (), outFace);
+ outFace->Send (packet);
+ }
+ else
+ {
+ NS_LOG_LOGIC ("Dropping -- outgoing interface is down: " << *outFace);
+ m_dropTrace (packet, DROP_INTERFACE_DOWN, m_node->GetObject<Ccnx> (), outFace);
+ }
}
-// 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)
{
@@ -600,12 +307,6 @@
}
}
-Ptr<NetDevice>
-CcnxL3Protocol::GetNetDevice (uint32_t i)
-{
- return GetInterface (i)->GetDevice ();
-}
-
void
CcnxL3Protocol::RouteInputError (Ptr<const Packet> p, const CcnxHeader & ipHeader, Socket::SocketErrno sockErrno)
{
diff --git a/model/ccnx-l3-protocol.h b/model/ccnx-l3-protocol.h
index d83f687..d45f0b3 100644
--- a/model/ccnx-l3-protocol.h
+++ b/model/ccnx-l3-protocol.h
@@ -15,7 +15,7 @@
// 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>
+// Author:
//
#ifndef CCNX_L3_PROTOCOL_H
@@ -34,12 +34,10 @@
class Packet;
class NetDevice;
class CcnxInterface;
-// class CcnxAddress;
-// class CcnxHeader;
-// class CcnxRoutingTableEntry;
class CcnxRoute;
class Node;
class Socket;
+class CcnxForwardingProtocol;
/**
@@ -73,9 +71,10 @@
*/
enum DropReason
{
- DROP_TTL_EXPIRED = 1, /**< Packet TTL has expired */
+ /** \todo Fill reasons from QualNet code */
+ DROP_DUPLICATE_INTEREST=1, /**< Duplicate Interest */
+ DROP_CONGESTION, /**< Congestion detected */
DROP_NO_ROUTE, /**< No route to host */
- DROP_BAD_CHECKSUM, /**< Bad checksum */
DROP_INTERFACE_DOWN, /**< Interface is down so can not send packet */
DROP_ROUTE_ERROR, /**< Route error */
};
@@ -83,19 +82,13 @@
void SetNode (Ptr<Node> node);
// functions defined in base class Ccnx
-
- // void SetRoutingProtocol (Ptr<CcnxRoutingProtocol> routingProtocol);
- // Ptr<CcnxRoutingProtocol> GetRoutingProtocol (void) const;
-
- // Ptr<Socket> CreateRawSocket (void);
- // void DeleteRawSocket (Ptr<Socket> socket);
+
+ void SetForwardingProtocol (Ptr<CcnxForwardingProtocol> forwardingProtocol);
+ Ptr<CcnxForwardingProtocol> GetForwardingProtocol (void) const;
/**
* Lower layer calls this method after calling L3Demux::Lookup
- * The ARP subclass needs to know from which NetDevice this
- * packet is coming to:
- * - implement a per-NetDevice ARP cache
- * - send back arp replies on the right device
+ *
* \param device network device
* \param p the packet
* \param protocol lower layer protocol value
@@ -103,75 +96,62 @@
* \param to lower layer address of the destination
* \param packetType type of the packet (broadcast/multicast/unicast/otherhost)
*/
- void Receive ( Ptr<NetDevice> device, Ptr<const Packet> p, uint16_t protocol,
+ void Receive (Ptr<NetDevice> device, Ptr<const Packet> p, uint16_t protocol,
const Address &from,
const Address &to,
NetDevice::PacketType packetType);
/**
+ * Actual processing of incoming CCNx packets. Also processing packets coming from local apps
+ */
+ void Receive (Ptr<CcnxFace> face, Ptr<const Packet> p);
+
+ /**
* \param packet packet to send
* \param route route entry
*
* Higher-level layers call this method to send a packet
* down the stack to the MAC and PHY layers.
*/
- void Send (Ptr<Packet> packet, Ptr<CcnxRoute> route);
+ virtual void Send (Ptr<Packet> packet, Ptr<CcnxRoute> route);
- uint32_t AddInterface (Ptr<NetDevice> device);
- Ptr<CcnxInterface> GetInterface (uint32_t i) const;
- uint32_t GetNInterfaces (void) const;
+ virtual uint32_t AddFace (Ptr<CcnxFace> face);
+ virtual uint32_t GetNFaces (void) const;
+ virtual Ptr<CcnxFace> GetFace (uint32_t face);
- int32_t GetInterfaceForDevice (Ptr<const NetDevice> device) const;
- // bool IsDestinationAddress (CcnxAddress address, uint32_t iif) const;
-
- void SetMetric (uint32_t i, uint16_t metric);
- uint16_t GetMetric (uint32_t i) const;
- uint16_t GetMtu (uint32_t i) const;
- bool IsUp (uint32_t i) const;
- void SetUp (uint32_t i);
- void SetDown (uint32_t i);
-
- Ptr<NetDevice> GetNetDevice (uint32_t i);
+ virtual void SetMetric (uint32_t i, uint16_t metric);
+ virtual uint16_t GetMetric (uint32_t i) const;
+ virtual uint16_t GetMtu (uint32_t i) const;
+ virtual bool IsUp (uint32_t i) const;
+ virtual void SetUp (uint32_t i);
+ virtual void SetDown (uint32_t i);
protected:
-
virtual void DoDispose (void);
/**
* This function will notify other components connected to the node that a new stack member is now connected
* This will be used to notify Layer 3 protocol of layer 4 protocol stack to connect them together.
*/
virtual void NotifyNewAggregate ();
+
private:
// friend class CcnxL3ProtocolTestCase;
CcnxL3Protocol(const CcnxL3Protocol &);
CcnxL3Protocol &operator = (const CcnxL3Protocol &);
- void
- SendRealOut (Ptr<CcnxRoute> route,
- Ptr<Packet> packet,
- CcnxHeader const &ipHeader);
-
- // void
- // IpForward (Ptr<CcnxRoute> rtentry,
- // Ptr<const Packet> p,
- // const CcnxHeader &header);
-
- // void
- // IpMulticastForward (Ptr<CcnxMulticastRoute> mrtentry,
- // Ptr<const Packet> p,
- // const CcnxHeader &header);
-
- void LocalDeliver (Ptr<const Packet> p, CcnxHeader const&ip, uint32_t iif);
+ /**
+ * Helper function to get CcnxFace from NetDevice
+ */
+ Ptr<CcnxFace> GetFaceForDevice (Ptr<const NetDevice> device) const;
+
void RouteInputError (Ptr<const Packet> p, const CcnxHeader & ipHeader, Socket::SocketErrno sockErrno);
- uint32_t AddCcnxInterface (Ptr<CcnxInterface> interface);
+private:
+ typedef std::vector<Ptr<CcnxFace> > CcnxFaceList;
+ CcnxFaceList m_faces;
- typedef std::vector<Ptr<CcnxInterface> > CcnxInterfaceList;
-
- CcnxInterfaceList m_interfaces;
- uint16_t m_identification;
Ptr<Node> m_node;
- CcnxL4Protocol m_layer4;
+ // Ptr<CcnxForwardingProtocol> m_forwardingProtocol;
TracedCallback<const CcnxHeader &, Ptr<const Packet>, uint32_t> m_sendOutgoingTrace;
TracedCallback<const CcnxHeader &, Ptr<const Packet>, uint32_t> m_unicastForwardTrace;
@@ -182,8 +162,6 @@
TracedCallback<Ptr<const Packet>, Ptr<Ccnx>, uint32_t> m_rxTrace;
// <ip-header, payload, reason, ifindex> (ifindex not valid if reason is DROP_NO_ROUTE)
TracedCallback<const CcnxHeader &, Ptr<const Packet>, DropReason, Ptr<Ccnx>, uint32_t> m_dropTrace;
-
- // Ptr<CcnxRoutingProtocol> m_routingProtocol;
};
} // Namespace ns3
diff --git a/model/ccnx-l4-protocol.cc b/model/ccnx-l4-protocol.cc
index 8c4d400..9cdd0a1 100644
--- a/model/ccnx-l4-protocol.cc
+++ b/model/ccnx-l4-protocol.cc
@@ -23,6 +23,8 @@
#include "ns3/uinteger.h"
+NS_LOG_COMPONENT_DEFINE ("CcnxL4Protocol");
+
namespace ns3 {
NS_OBJECT_ENSURE_REGISTERED (CcnxL4Protocol);
@@ -36,8 +38,70 @@
return tid;
}
+CcnxL4Protocol::CcnxL4Protocol ()
+{
+ NS_LOG_FUNCTION_NOARGS ();
+}
+
CcnxL4Protocol::~CcnxL4Protocol ()
{
+ NS_LOG_FUNCTION_NOARGS ();
+}
+
+void
+CcnxL4Protocol::SetNode (Ptr<Node> node)
+{
+ m_node = node;
+}
+
+/*
+ * This method is called by AddAgregate and completes the aggregation
+ * by setting the node in the udp stack and link it to the ipv4 object
+ * present in the node along with the socket factory
+ */
+void
+CcnxL4Protocol::NotifyNewAggregate ()
+{
+ if (m_node == 0)
+ {
+ Ptr<Node> node = this->GetObject<Node> ();
+ if (node != 0)
+ {
+ Ptr<Ccnx> ccnx = this->GetObject<Ccnx> ();
+ if (ccnx != 0)
+ {
+ this->SetNode (node);
+ ccnx->Insert (this);
+ // Ptr<UdpSocketFactoryImpl> udpFactory = CreateObject<UdpSocketFactoryImpl> ();
+ // udpFactory->SetUdp (this);
+ // node->AggregateObject (udpFactory);
+ this->SetDownTarget (MakeCallback (&Ccnx::Send, ccnx));
+ }
+ }
+ }
+ Object::NotifyNewAggregate ();
+}
+
+void
+CcnxL4Protocol::DoDispose (void)
+{
+ NS_LOG_FUNCTION_NOARGS ();
+
+ m_node = 0;
+ m_downTarget.Nullify ();
+ CcnxL4Protocol::DoDispose ();
+}
+
+void
+SetDownTarget (DownTargetCallback cb)
+{
+ m_downTarget = cb;
+}
+
+DownTargetCallback
+GetDownTarget (void) const
+{
+ retur m_downTarget;
}
} //namespace ns3
diff --git a/model/ccnx-l4-protocol.h b/model/ccnx-l4-protocol.h
index 14aceef..e0a6aed 100644
--- a/model/ccnx-l4-protocol.h
+++ b/model/ccnx-l4-protocol.h
@@ -48,8 +48,11 @@
static TypeId GetTypeId (void);
+ CcnxL4Protocol ();
virtual ~CcnxL4Protocol ();
+ void SetNode (Ptr<Node> node);
+
/**
* \param p packet to forward up
* \param header Ccnx Header information
@@ -60,7 +63,7 @@
*/
virtual enum RxStatus Receive (Ptr<Packet> p,
CcnxHeader const &header,
- Ptr<CcnxInterface> incomingInterface) = 0;
+ Ptr<CcnxInterface> incomingInterface);
typedef Callback<void,Ptr<Packet>, Ptr<CcnxRoute> > DownTargetCallback;
/**
@@ -69,14 +72,25 @@
*
* \param cb current Callback for the L4 protocol
*/
- virtual void SetDownTarget (DownTargetCallback cb) = 0;
+ virtual void SetDownTarget (DownTargetCallback cb);
/**
* This method allows a caller to get the current down target callback
* set for this L4 protocol, for
*
* \return current Callback for the L4 protocol
*/
- virtual DownTargetCallback GetDownTarget (void) const = 0;
+ virtual DownTargetCallback GetDownTarget (void) const;
+
+protected:
+ virtual void DoDispose (void);
+ /*
+ * This function will notify other components connected to the node that a new stack member is now connected
+ * This will be used to notify Layer 3 protocol of layer 4 protocol stack to connect them together.
+ */
+ virtual void NotifyNewAggregate ();
+
+private:
+ DownTargetCallback m_downTarget;
};
} // Namespace ns3
diff --git a/model/ccnx-local-face.cc b/model/ccnx-local-face.cc
new file mode 100644
index 0000000..aeb2002
--- /dev/null
+++ b/model/ccnx-local-face.cc
@@ -0,0 +1,104 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2005,2006,2007 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
+ *
+ * Author:
+ *
+ */
+
+#include "ccnx-local-face.h"
+
+#include "ns3/ccnx-address.h"
+#include "ns3/ccnx-l3-protocol.h"
+#include "ns3/net-device.h"
+#include "ns3/log.h"
+#include "ns3/packet.h"
+#include "ns3/node.h"
+#include "ns3/pointer.h"
+#include "ns3/assert.h"
+
+NS_LOG_COMPONENT_DEFINE ("CcnxLocalFace");
+
+namespace ns3 {
+
+NS_OBJECT_ENSURE_REGISTERED (CcnxLocalFace);
+
+TypeId
+CcnxLocalFace::GetTypeId (void)
+{
+ static TypeId tid = TypeId ("ns3::CcnxLocalFace")
+ .SetParent<Object> ()
+ ;
+ return tid;
+}
+
+/**
+ * By default, Ccnx interface are created in the "down" state
+ * with no IP addresses. Before becoming useable, the user must
+ * invoke SetUp on them once an Ccnx address and mask have been set.
+ */
+CcnxLocalFace::CcnxLocalFace ()
+{
+ NS_LOG_FUNCTION (this);
+}
+
+CcnxLocalFace::~CcnxLocalFace ()
+{
+ NS_LOG_FUNCTION_NOARGS ();
+}
+
+void
+CcnxLocalFace::DoDispose (void)
+{
+ NS_LOG_FUNCTION_NOARGS ();
+ CcnxFace::DoDispose ();
+}
+
+void
+CcnxLocalFace::SetDevice (Ptr<NetDevice> device)
+{
+ assert (false);
+}
+
+Ptr<NetDevice>
+CcnxLocalFace::GetDevice (void) const
+{
+ assert (false)
+}
+
+
+
+void
+CcnxLocalFace::Send (Ptr<Packet> p)
+{
+ NS_LOG_FUNCTION (*p);
+ if (!IsUp ())
+ {
+ return;
+ }
+
+ // m_device->Send (p, m_device->GetBroadcast (),
+ // CcnxL3Protocol::PROT_NUMBER);
+}
+
+std::ostream& operator<< (std::ostream& os, CcnxLocalFace const& localFace)
+{
+ os << "dev=local";
+ return os;
+}
+
+}; // namespace ns3
+
diff --git a/model/ccnx-local-face.h b/model/ccnx-local-face.h
new file mode 100644
index 0000000..33d884a
--- /dev/null
+++ b/model/ccnx-local-face.h
@@ -0,0 +1,74 @@
+/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2005,2006,2007 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:
+ */
+#ifndef CCNX_LOCAL_FACE_H
+#define CCNX_LOCAL_FACE_H
+
+#include "ccnx-face.h"
+
+namespace ns3 {
+
+class NetDevice;
+class Packet;
+class Node;
+
+/**
+ * \brief The Ccnx representation of a network interface
+ *
+ * This class roughly corresponds to the struct in_device
+ * of Linux; the main purpose is to provide address-family
+ * specific information (addresses) about an interface.
+ *
+ * By default, Ccnx interface are created in the "down" state
+ * no IP addresses. Before becoming useable, the user must
+ * add an address of some type and invoke Setup on them.
+ */
+class CcnxLocalFace : public CcnxFace
+{
+public:
+ static TypeId GetTypeId (void);
+
+ CcnxLocalFace ();
+ virtual ~CcnxLocalFace();
+
+ // Create ();
+
+ // Create (Name::Components);
+
+ // typedef callback ?
+
+ /**
+ * \param p packet to send
+ */
+ virtual void Send (Ptr<Packet> p);
+
+protected:
+ virtual void DoDispose (void);
+
+private:
+ /** disabled for LocalFace **/
+ virtual Ptr<NetDevice> GetDevice (void) const;
+ virtual void SetDevice (Ptr<NetDevice> device);
+};
+
+std::ostream& operator<< (std::ostream& os, CcnxLocalFace const& localFace);
+
+} // namespace ns3
+
+#endif
diff --git a/model/ccnx-route.cc b/model/ccnx-route.cc
index 704f08c..98e8b7b 100644
--- a/model/ccnx-route.cc
+++ b/model/ccnx-route.cc
@@ -19,7 +19,7 @@
#include "ccnx-route.h"
-#include "ns3/net-device.h"
+#include "ns3/ccnx-face.h"
#include "ns3/assert.h"
namespace ns3 {
@@ -41,20 +41,20 @@
}
void
-CcnxRoute::SetOutputDevice (Ptr<NetDevice> outputDevice)
+CcnxRoute::SetOutputFace (Ptr<CcnxFace> outputFace)
{
- m_outputDevice = outputDevice;
+ m_outputFace = outputFace;
}
-Ptr<NetDevice>
-CcnxRoute::GetOutputDevice (void) const
+Ptr<CcnxFace>
+CcnxRoute::GetOutputFace (void) const
{
- return m_outputDevice;
+ return m_outputFace;
}
std::ostream& operator<< (std::ostream& os, CcnxRoute const& route)
{
- os << "prefix=" << route.GetPrefix () << ", dev=" << route.GetOutputDevice ()->GetIfIndex ();
+ os << "prefix=" << route.GetPrefix () << ", " << route.GetOutputFace ();
return os;
}
diff --git a/model/ccnx-route.h b/model/ccnx-route.h
index 9502330..c3d7e5e 100644
--- a/model/ccnx-route.h
+++ b/model/ccnx-route.h
@@ -24,10 +24,11 @@
#include <ostream>
#include "ns3/simple-ref-count.h"
+#include "ns3/name-components.h"
namespace ns3 {
-class NetDevice;
+class CcnxFace;
/**
* \ingroup ccnxRouting
@@ -56,20 +57,19 @@
*
* \param outputDevice pointer to NetDevice for outgoing packets
*/
- void SetOutputDevice (Ptr<NetDevice> outputDevice);
+ void SetOutputFace (Ptr<CcnxFace> outputDevice);
/**
* \return pointer to NetDevice for outgoing packets
*/
- Ptr<NetDevice> GetOutputDevice (void) const;
+ Ptr<CcnxFace> GetOutputFace (void) const;
private:
Name::Components m_prefix;
- Ptr<NetDevice> m_outputDevice;
+ Ptr<CcnxFace> m_outputFace;
};
std::ostream& operator<< (std::ostream& os, CcnxRoute const& route);
-} //namespace NDNabstraction
} //namespace ns3
#endif /* CCNX_ROUTE_H */
diff --git a/model/ccnx.cc b/model/ccnx.cc
index 8a5e6d0..f54d1b0 100644
--- a/model/ccnx.cc
+++ b/model/ccnx.cc
@@ -21,6 +21,7 @@
#include "ns3/assert.h"
#include "ns3/node.h"
#include "ns3/boolean.h"
+
#include "ccnx.h"
namespace ns3 {
diff --git a/model/ccnx.h b/model/ccnx.h
index 9196067..40e2678 100644
--- a/model/ccnx.h
+++ b/model/ccnx.h
@@ -15,7 +15,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
- * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
+ * Author:
*/
#ifndef CCNX_H
#define CCNX_H
@@ -90,12 +90,12 @@
* to disable it, you can invoke Ccnx::SetDown which will
* make sure that it is never used during packet forwarding.
*/
- virtual uint32_t AddInterface (Ptr<NetDevice> device) = 0;
+ virtual uint32_t AddFace (Ptr<CcnxFace> face) = 0;
/**
* \returns the number of interfaces added by the user.
*/
- virtual uint32_t GetNInterfaces (void) const = 0;
+ virtual uint32_t GetNFaces (void) const = 0;
/**
* \param packet packet to send
@@ -104,63 +104,63 @@
* Higher-level layers call this method to send a packet
* down the stack to the MAC and PHY layers.
*/
- virtual void Send (Ptr<Packet> packet, Ptr<CcnxRoute> route) = 0;
+ // virtual void Send (Ptr<Packet> packet, Ptr<CcnxRoute> route) = 0;
/**
- * \param interface The interface number of an Ccnx interface.
- * \returns The NetDevice associated with the Ccnx interface number.
+ * \param face The face number of an Ccnx interface.
+ * \returns The CcnxFace associated with the Ccnx face number.
*/
- virtual Ptr<NetDevice> GetNetDevice (uint32_t interface) = 0;
+ virtual Ptr<CcnxFace> GetFace (uint32_t face) = 0;
+
+ // /**
+ // * \param face CcnxFace object pointer
+ // * \returns The interface number of an Ccnx face or -1 if not found.
+ // */
+ // virtual int32_t GetFaceForDevice (Ptr<const CcnxFace> face) const = 0;
/**
- * \param device The NetDevice for an CcnxInterface
- * \returns The interface number of an Ccnx interface or -1 if not found.
- */
- virtual int32_t GetInterfaceForDevice (Ptr<const NetDevice> device) const = 0;
-
- /**
- * \param interface The interface number of an Ccnx interface
+ * \param face The face number of an Ccnx face
* \param metric routing metric (cost) associated to the underlying
* Ccnx interface
*/
- virtual void SetMetric (uint32_t interface, uint16_t metric) = 0;
+ virtual void SetMetric (uint32_t face, uint16_t metric) = 0;
/**
- * \param interface The interface number of an Ccnx interface
+ * \param face The interface number of an Ccnx interface
* \returns routing metric (cost) associated to the underlying
* Ccnx interface
*/
- virtual uint16_t GetMetric (uint32_t interface) const = 0;
+ virtual uint16_t GetMetric (uint32_t face) const = 0;
/**
- * \param interface Interface number of Ccnx interface
+ * \param face Interface number of Ccnx interface
* \returns the Maximum Transmission Unit (in bytes) associated
* to the underlying Ccnx interface
*/
- virtual uint16_t GetMtu (uint32_t interface) const = 0;
+ virtual uint16_t GetMtu (uint32_t face) const = 0;
/**
- * \param interface Interface number of Ccnx interface
+ * \param face Interface number of Ccnx interface
* \returns true if the underlying interface is in the "up" state,
* false otherwise.
*/
- virtual bool IsUp (uint32_t interface) const = 0;
+ virtual bool IsUp (uint32_t face) const = 0;
/**
- * \param interface Interface number of Ccnx interface
+ * \param face Interface number of Ccnx interface
*
* Set the interface into the "up" state. In this state, it is
* considered valid during Ccnx forwarding.
*/
- virtual void SetUp (uint32_t interface) = 0;
+ virtual void SetUp (uint32_t face) = 0;
/**
- * \param interface Interface number of Ccnx interface
+ * \param face Interface number of Ccnx interface
*
* Set the interface into the "down" state. In this state, it is
* ignored during Ccnx forwarding.
*/
- virtual void SetDown (uint32_t interface) = 0;
+ virtual void SetDown (uint32_t face) = 0;
};
} // namespace ns3