First approximation of CCNx protocol stack
diff --git a/model/ccnx-l3-protocol.h b/model/ccnx-l3-protocol.h
new file mode 100644
index 0000000..d83f687
--- /dev/null
+++ b/model/ccnx-l3-protocol.h
@@ -0,0 +1,191 @@
+// -*- 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>
+//
+
+#ifndef CCNX_L3_PROTOCOL_H
+#define CCNX_L3_PROTOCOL_H
+
+#include <list>
+#include <vector>
+#include <stdint.h>
+#include "ns3/ptr.h"
+#include "ns3/net-device.h"
+#include "ns3/ccnx.h"
+#include "ns3/traced-callback.h"
+
+namespace ns3 {
+
+class Packet;
+class NetDevice;
+class CcnxInterface;
+// class CcnxAddress;
+// class CcnxHeader;
+// class CcnxRoutingTableEntry;
+class CcnxRoute;
+class Node;
+class Socket;
+
+
+/**
+ * \brief Implement the Ccnx layer.
+ *
+ * This is the actual implementation of IP. It contains APIs to send and
+ * receive packets at the IP layer, as well as APIs for IP routing.
+ *
+ * This class contains two distinct groups of trace sources. The
+ * trace sources 'Rx' and 'Tx' are called, respectively, immediately
+ * after receiving from the NetDevice and immediately before sending
+ * to a NetDevice for transmitting a packet. These are low level
+ * trace sources that include the CcnxHeader already serialized into
+ * the packet. In contrast, the Drop, SendOutgoing, UnicastForward,
+ * and LocalDeliver trace sources are slightly higher-level and pass
+ * around the CcnxHeader as an explicit parameter and not as part of
+ * the packet.
+ */
+class CcnxL3Protocol : public Ccnx
+{
+public:
+ static TypeId GetTypeId (void);
+ static const uint16_t PROT_NUMBER;
+
+ CcnxL3Protocol();
+ virtual ~CcnxL3Protocol ();
+
+ /**
+ * \enum DropReason
+ * \brief Reason why a packet has been dropped.
+ */
+ enum DropReason
+ {
+ DROP_TTL_EXPIRED = 1, /**< Packet TTL has expired */
+ 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 */
+ };
+
+ 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);
+
+ /**
+ * 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
+ * \param from lower layer address of the correspondant
+ * \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,
+ const Address &from,
+ const Address &to,
+ NetDevice::PacketType packetType);
+
+ /**
+ * \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);
+
+ uint32_t AddInterface (Ptr<NetDevice> device);
+ Ptr<CcnxInterface> GetInterface (uint32_t i) const;
+ uint32_t GetNInterfaces (void) const;
+
+ 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);
+
+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);
+ void RouteInputError (Ptr<const Packet> p, const CcnxHeader & ipHeader, Socket::SocketErrno sockErrno);
+
+ uint32_t AddCcnxInterface (Ptr<CcnxInterface> interface);
+
+ typedef std::vector<Ptr<CcnxInterface> > CcnxInterfaceList;
+
+ CcnxInterfaceList m_interfaces;
+ uint16_t m_identification;
+ Ptr<Node> m_node;
+ CcnxL4Protocol m_layer4;
+
+ TracedCallback<const CcnxHeader &, Ptr<const Packet>, uint32_t> m_sendOutgoingTrace;
+ TracedCallback<const CcnxHeader &, Ptr<const Packet>, uint32_t> m_unicastForwardTrace;
+ TracedCallback<const CcnxHeader &, Ptr<const Packet>, uint32_t> m_localDeliverTrace;
+
+ // The following two traces pass a packet with an IP header
+ TracedCallback<Ptr<const Packet>, Ptr<Ccnx>, uint32_t> m_txTrace;
+ 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
+
+#endif /* CCNX_L3_PROTOCOL_H */