ns-3-simu_zebra_ipv6-2nd

changeset 4775:fc2c29a13125
After support for TD/NINA on zebra-0.95
author: tazaki@vmlinux-zak
date: Thu Oct 01 23:37:18 2009 +0900 (2 years ago)
parents: 86acc8e9b3e6
children: bd7211da3ecd
files: .hgignore bindings/python/ns3_module_contrib.py bindings/python/wscript src/contrib/wscript src/helper/internet-stack-helper.cc src/helper/ipv6-interface-container.cc src/helper/netlink-socket-helper.cc src/helper/netlink-socket-helper.h src/helper/node-container.cc src/helper/node-container.h src/helper/wscript src/internet-stack/ipv6-l3-protocol.cc src/internet-stack/ipv6-l3-protocol.h src/internet-stack/ipv6-raw-socket-impl.cc src/internet-stack/ipv6-raw-socket-impl.h src/internet-stack/tcp6-l4-protocol.cc src/internet-stack/tcp6-l4-protocol.h src/internet-stack/tcp6-socket-factory-impl.cc src/internet-stack/tcp6-socket-factory-impl.h src/internet-stack/tcp6-socket-impl.cc src/internet-stack/tcp6-socket-impl.h src/internet-stack/wscript src/mobility/oneway-mobility-model.cc src/mobility/oneway-mobility-model.h src/mobility/wscript src/node/ipv6-address.cc src/node/ipv6-address.h src/node/netlink-attribute.cc src/node/netlink-attribute.h src/node/netlink-ipv6-routing-table.cc src/node/netlink-ipv6-routing-table.h src/node/netlink-message-route.cc src/node/netlink-message-route.h src/node/netlink-message.cc src/node/netlink-message.h src/node/netlink-socket-address.cc src/node/netlink-socket-address.h src/node/netlink-socket-factory.cc src/node/netlink-socket-factory.h src/node/netlink-socket-test.cc src/node/netlink-socket.cc src/node/netlink-socket.h src/node/node.cc src/node/socket.cc src/node/socket.h src/node/tcp6-socket-factory.cc src/node/tcp6-socket-factory.h src/node/wscript src/process-manager/libc-simu.c src/process-manager/libc.c src/process-manager/libc.h src/process-manager/simu-fd.cc src/process-manager/simu-stdio.cc src/process-manager/unix-datagram-socket-fd.cc src/process-manager/unix-socket-fd.cc src/process-manager/unix-socket-fd.h src/process-manager/utils.cc wscript wutils.py
--- a/.hgignore	Mon Sep 07 15:45:12 2009 +0200
+++ b/.hgignore	Thu Oct 01 23:37:18 2009 +0900
@@ -33,4 +33,7 @@
-\#[^\#/]+\#$
+\#[^\#/]+\#$
+files-*
+elf-loader-cache
+G.*
--- a/bindings/python/ns3_module_contrib.py	Mon Sep 07 15:45:12 2009 +0200
+++ b/bindings/python/ns3_module_contrib.py	Thu Oct 01 23:37:18 2009 +0900
@@ -39,6 +39,21 @@
+    ## pyviz.h: ns3::PyViz [class]
+    module.add_class('PyViz')
+    ## pyviz.h: ns3::PyViz::LastPacketsSample [struct]
+    module.add_class('LastPacketsSample', outer_class=root_module['ns3::PyViz'])
+    ## pyviz.h: ns3::PyViz::NetDeviceStatistics [struct]
+    module.add_class('NetDeviceStatistics', outer_class=root_module['ns3::PyViz'])
+    ## pyviz.h: ns3::PyViz::NodeStatistics [struct]
+    module.add_class('NodeStatistics', outer_class=root_module['ns3::PyViz'])
+    ## pyviz.h: ns3::PyViz::PacketDropSample [struct]
+    module.add_class('PacketDropSample', outer_class=root_module['ns3::PyViz'])
+    ## pyviz.h: ns3::PyViz::PacketSample [struct]
+    module.add_class('PacketSample', outer_class=root_module['ns3::PyViz'])
+    ## pyviz.h: ns3::PyViz::TransmissionSample [struct]
+    module.add_class('TransmissionSample', outer_class=root_module['ns3::PyViz'])
+
@@ -105,6 +120,13 @@
+    register_Ns3PyViz_methods(root_module, root_module['ns3::PyViz'])
+    register_Ns3PyVizLastPacketsSample_methods(root_module, root_module['ns3::PyViz::LastPacketsSample'])
+    register_Ns3PyVizNetDeviceStatistics_methods(root_module, root_module['ns3::PyViz::NetDeviceStatistics'])
+    register_Ns3PyVizNodeStatistics_methods(root_module, root_module['ns3::PyViz::NodeStatistics'])
+    register_Ns3PyVizPacketDropSample_methods(root_module, root_module['ns3::PyViz::PacketDropSample'])
+    register_Ns3PyVizPacketSample_methods(root_module, root_module['ns3::PyViz::PacketSample'])
+    register_Ns3PyVizTransmissionSample_methods(root_module, root_module['ns3::PyViz::TransmissionSample'])
@@ -500,3 +522,131 @@
+def register_Ns3PyViz_methods(root_module, cls):
+    ## pyviz.h: ns3::PyViz::PyViz(ns3::PyViz const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PyViz const &', 'arg0')])
+    ## pyviz.h: ns3::PyViz::PyViz() [constructor]
+    cls.add_constructor([])
+    ## pyviz.h: ns3::PyViz::LastPacketsSample ns3::PyViz::GetLastPackets(uint32_t nodeId) const [member function]
+    cls.add_method('GetLastPackets', 
+                   'ns3::PyViz::LastPacketsSample', 
+                   [param('uint32_t', 'nodeId')], 
+                   is_const=True)
+    ## pyviz.h: std::vector<ns3::PyViz::NodeStatistics,std::allocator<ns3::PyViz::NodeStatistics> > ns3::PyViz::GetNodesStatistics() const [member function]
+    cls.add_method('GetNodesStatistics', 
+                   'std::vector< ns3::PyViz::NodeStatistics >', 
+                   [], 
+                   is_const=True)
+    ## pyviz.h: std::vector<ns3::PyViz::PacketDropSample,std::allocator<ns3::PyViz::PacketDropSample> > ns3::PyViz::GetPacketDropSamples() const [member function]
+    cls.add_method('GetPacketDropSamples', 
+                   'std::vector< ns3::PyViz::PacketDropSample >', 
+                   [], 
+                   is_const=True)
+    ## pyviz.h: std::vector<std::string, std::allocator<std::string> > ns3::PyViz::GetPauseMessages() const [member function]
+    cls.add_method('GetPauseMessages', 
+                   'std::vector< std::string >', 
+                   [], 
+                   is_const=True)
+    ## pyviz.h: std::vector<ns3::PyViz::TransmissionSample,std::allocator<ns3::PyViz::TransmissionSample> > ns3::PyViz::GetTransmissionSamples() const [member function]
+    cls.add_method('GetTransmissionSamples', 
+                   'std::vector< ns3::PyViz::TransmissionSample >', 
+                   [], 
+                   is_const=True)
+    ## pyviz.h: static void ns3::PyViz::Pause(std::string const & message) [member function]
+    cls.add_method('Pause', 
+                   'void', 
+                   [param('std::string const &', 'message')], 
+                   is_static=True)
+    ## pyviz.h: void ns3::PyViz::RegisterDropTracePath(std::string const & tracePath) [member function]
+    cls.add_method('RegisterDropTracePath', 
+                   'void', 
+                   [param('std::string const &', 'tracePath')])
+    ## pyviz.h: void ns3::PyViz::SetNodesOfInterest(std::set<unsigned int, std::less<unsigned int>, std::allocator<unsigned int> > nodes) [member function]
+    cls.add_method('SetNodesOfInterest', 
+                   'void', 
+                   [param('std::set< unsigned int >', 'nodes')])
+    ## pyviz.h: void ns3::PyViz::SimulatorRunUntil(ns3::Time time) [member function]
+    cls.add_method('SimulatorRunUntil', 
+                   'void', 
+                   [param('ns3::Time', 'time')])
+    return
+
+def register_Ns3PyVizLastPacketsSample_methods(root_module, cls):
+    ## pyviz.h: ns3::PyViz::LastPacketsSample::LastPacketsSample() [constructor]
+    cls.add_constructor([])
+    ## pyviz.h: ns3::PyViz::LastPacketsSample::LastPacketsSample(ns3::PyViz::LastPacketsSample const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PyViz::LastPacketsSample const &', 'arg0')])
+    ## pyviz.h: ns3::PyViz::LastPacketsSample::lastDroppedPackets [variable]
+    cls.add_instance_attribute('lastDroppedPackets', 'std::vector< ns3::PyViz::PacketSample >', is_const=False)
+    ## pyviz.h: ns3::PyViz::LastPacketsSample::lastReceivedPackets [variable]
+    cls.add_instance_attribute('lastReceivedPackets', 'std::vector< ns3::PyViz::PacketSample >', is_const=False)
+    ## pyviz.h: ns3::PyViz::LastPacketsSample::lastTransmittedPackets [variable]
+    cls.add_instance_attribute('lastTransmittedPackets', 'std::vector< ns3::PyViz::PacketSample >', is_const=False)
+    return
+
+def register_Ns3PyVizNetDeviceStatistics_methods(root_module, cls):
+    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::NetDeviceStatistics(ns3::PyViz::NetDeviceStatistics const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PyViz::NetDeviceStatistics const &', 'arg0')])
+    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::NetDeviceStatistics() [constructor]
+    cls.add_constructor([])
+    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::receivedBytes [variable]
+    cls.add_instance_attribute('receivedBytes', 'uint64_t', is_const=False)
+    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::receivedPackets [variable]
+    cls.add_instance_attribute('receivedPackets', 'uint32_t', is_const=False)
+    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::transmittedBytes [variable]
+    cls.add_instance_attribute('transmittedBytes', 'uint64_t', is_const=False)
+    ## pyviz.h: ns3::PyViz::NetDeviceStatistics::transmittedPackets [variable]
+    cls.add_instance_attribute('transmittedPackets', 'uint32_t', is_const=False)
+    return
+
+def register_Ns3PyVizNodeStatistics_methods(root_module, cls):
+    ## pyviz.h: ns3::PyViz::NodeStatistics::NodeStatistics() [constructor]
+    cls.add_constructor([])
+    ## pyviz.h: ns3::PyViz::NodeStatistics::NodeStatistics(ns3::PyViz::NodeStatistics const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PyViz::NodeStatistics const &', 'arg0')])
+    ## pyviz.h: ns3::PyViz::NodeStatistics::nodeId [variable]
+    cls.add_instance_attribute('nodeId', 'uint32_t', is_const=False)
+    ## pyviz.h: ns3::PyViz::NodeStatistics::statistics [variable]
+    cls.add_instance_attribute('statistics', 'std::vector< ns3::PyViz::NetDeviceStatistics >', is_const=False)
+    return
+
+def register_Ns3PyVizPacketDropSample_methods(root_module, cls):
+    ## pyviz.h: ns3::PyViz::PacketDropSample::PacketDropSample() [constructor]
+    cls.add_constructor([])
+    ## pyviz.h: ns3::PyViz::PacketDropSample::PacketDropSample(ns3::PyViz::PacketDropSample const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PyViz::PacketDropSample const &', 'arg0')])
+    ## pyviz.h: ns3::PyViz::PacketDropSample::bytes [variable]
+    cls.add_instance_attribute('bytes', 'uint32_t', is_const=False)
+    ## pyviz.h: ns3::PyViz::PacketDropSample::transmitter [variable]
+    cls.add_instance_attribute('transmitter', 'ns3::Ptr< ns3::Node >', is_const=False)
+    return
+
+def register_Ns3PyVizPacketSample_methods(root_module, cls):
+    ## pyviz.h: ns3::PyViz::PacketSample::PacketSample() [constructor]
+    cls.add_constructor([])
+    ## pyviz.h: ns3::PyViz::PacketSample::PacketSample(ns3::PyViz::PacketSample const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PyViz::PacketSample const &', 'arg0')])
+    ## pyviz.h: ns3::PyViz::PacketSample::device [variable]
+    cls.add_instance_attribute('device', 'ns3::Ptr< ns3::NetDevice >', is_const=False)
+    ## pyviz.h: ns3::PyViz::PacketSample::packet [variable]
+    cls.add_instance_attribute('packet', 'ns3::Ptr< ns3::Packet >', is_const=False)
+    ## pyviz.h: ns3::PyViz::PacketSample::time [variable]
+    cls.add_instance_attribute('time', 'ns3::Time', is_const=False)
+    return
+
+def register_Ns3PyVizTransmissionSample_methods(root_module, cls):
+    ## pyviz.h: ns3::PyViz::TransmissionSample::TransmissionSample() [constructor]
+    cls.add_constructor([])
+    ## pyviz.h: ns3::PyViz::TransmissionSample::TransmissionSample(ns3::PyViz::TransmissionSample const & arg0) [copy constructor]
+    cls.add_constructor([param('ns3::PyViz::TransmissionSample const &', 'arg0')])
+    ## pyviz.h: ns3::PyViz::TransmissionSample::bytes [variable]
+    cls.add_instance_attribute('bytes', 'uint32_t', is_const=False)
+    ## pyviz.h: ns3::PyViz::TransmissionSample::channel [variable]
+    cls.add_instance_attribute('channel', 'ns3::Ptr< ns3::Channel >', is_const=False)
+    ## pyviz.h: ns3::PyViz::TransmissionSample::receiver [variable]
+    cls.add_instance_attribute('receiver', 'ns3::Ptr< ns3::Node >', is_const=False)
+    ## pyviz.h: ns3::PyViz::TransmissionSample::transmitter [variable]
+    cls.add_instance_attribute('transmitter', 'ns3::Ptr< ns3::Node >', is_const=False)
+    return
+
+
--- a/bindings/python/wscript	Mon Sep 07 15:45:12 2009 +0200
+++ b/bindings/python/wscript	Thu Oct 01 23:37:18 2009 +0900
@@ -15,6 +15,7 @@
+#REQUIRED_PYBINDGEN_VERSION = (0, 12, 0, 700)
--- a/src/contrib/wscript	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/contrib/wscript	Thu Oct 01 23:37:18 2009 +0900
@@ -30,6 +30,7 @@
+        'pyviz.cc',
@@ -41,6 +42,7 @@
+        'pyviz.h',
@@ -54,3 +56,5 @@
+
+    bld.add_subdirs('visualizer')
--- a/src/helper/internet-stack-helper.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/helper/internet-stack-helper.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -315,6 +315,9 @@
+      ObjectFactory m_tcp6Factory;
+      m_tcp6Factory.SetTypeId ("ns3::Tcp6L4Protocol");
+      node->AggregateObject (m_tcp6Factory.Create<Object> ());
--- a/src/helper/ipv6-interface-container.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/helper/ipv6-interface-container.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -87,7 +87,7 @@
-        routing->SetDefaultRoute (routerAddress, m_interfaces[other].second);
+        //        routing->SetDefaultRoute (routerAddress, m_interfaces[other].second);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/helper/netlink-socket-helper.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,30 @@
+#include "netlink-socket-helper.h"
+#include "ns3/netlink-socket-factory.h"
+#include "ns3/netlink-ipv6-routing-table.h"
+#include "ns3/ipv6-list-routing.h"
+
+namespace ns3 {
+
+void 
+NetlinkSocketHelper::Install (NodeContainer c)
+{
+  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
+    {
+      Ptr<Node> node = *i;
+      Ptr<NetlinkSocketFactory> factory = CreateObject<NetlinkSocketFactory> ();
+      node->AggregateObject (factory);
+
+      Ptr<Ipv6RoutingProtocol> ipv6rp = node->GetObject<Ipv6>()->GetRoutingProtocol ();
+      NS_ASSERT_MSG (ipv6rp, "No routing protocol associated with Ipv6");
+      if (DynamicCast<Ipv6ListRouting> (ipv6rp))
+        {
+          Ptr<Ipv6ListRouting> lrp = DynamicCast<Ipv6ListRouting> (ipv6rp);
+
+          Ptr<NetlinkIpv6RoutingTable> table = CreateObject<NetlinkIpv6RoutingTable> ();
+          lrp->AddRoutingProtocol (table, -20); // FIXME
+          node->AggregateObject (table);
+        }
+    }
+}
+
+} // namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/helper/netlink-socket-helper.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,25 @@
+#ifndef NETLINK_SOCKET_HELPER_H
+#define NETLINK_SOCKET_HELPER_H
+
+#include "ns3/node-container.h"
+
+namespace ns3 {
+
+/**
+ * \brief Give ns3::NetlinkSocket powers to ns3::Node.
+ */
+class NetlinkSocketHelper
+{
+public:
+  /**
+   * \param c container of node pointers
+   *
+   * For each node in the input container, aggregate a ns3::NetlinkSocketFactory
+   * object instance.
+   */
+  void Install (NodeContainer c);
+};
+
+} // namespace ns3
+
+#endif /* NETLINK_SOCKET_HELPER_H */
--- a/src/helper/node-container.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/helper/node-container.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -88,6 +88,16 @@
+NodeContainer 
+NodeContainer::Get (uint32_t start, uint32_t end) const
+{
+  NodeContainer nodes;
+  for (uint32_t i = start; i < end; i++)
+    {
+      nodes.Add (m_nodes[i]);
+    }
+  return nodes;
+}
--- a/src/helper/node-container.h	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/helper/node-container.h	Thu Oct 01 23:37:18 2009 +0900
@@ -91,6 +91,7 @@
+  NodeContainer Get (uint32_t start, uint32_t end) const;
--- a/src/helper/wscript	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/helper/wscript	Thu Oct 01 23:37:18 2009 +0900
@@ -37,6 +37,7 @@
+        'netlink-socket-helper.cc',
@@ -76,6 +77,7 @@
+        'netlink-socket-helper.h',
--- a/src/internet-stack/ipv6-l3-protocol.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/internet-stack/ipv6-l3-protocol.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -69,7 +69,8 @@
-  : m_nInterfaces (0)
+  : m_nInterfaces (0),
+    m_acceptRtadvDefrtr(true)
@@ -593,6 +594,13 @@
+void Ipv6L3Protocol::SetAcceptRtadvDefrtr(bool flag)
+{
+  NS_LOG_FUNCTION(this << flag);
+  m_acceptRtadvDefrtr=flag;
+}
+
+
--- a/src/internet-stack/ipv6-l3-protocol.h	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/internet-stack/ipv6-l3-protocol.h	Thu Oct 01 23:37:18 2009 +0900
@@ -307,6 +307,8 @@
+    void SetAcceptRtadvDefrtr(bool flag);
+
@@ -478,6 +480,8 @@
+
+    bool m_acceptRtadvDefrtr;
--- a/src/internet-stack/ipv6-raw-socket-impl.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/internet-stack/ipv6-raw-socket-impl.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -48,10 +48,12 @@
+#ifdef FIXME
+#endif
@@ -66,6 +68,7 @@
+  m_ifIndex = 0;
@@ -212,6 +215,10 @@
+    else
+      {
+        oif = m_ifIndex;
+      }
@@ -239,7 +246,7 @@
-  return 0;
+  return p->GetSize();
@@ -315,11 +322,13 @@
-      if ((1 << type) & m_icmpFilter)
-      {
-        /* packet filtered */
-        return false;
-      }
+      if (ICMP6_FILTER_WILLBLOCK(type, &m_icmpFilter))
+        {
+          NS_LOG_DEBUG("Dropped by ICMP6 filter type=" << (uint32_t)type << " on " << this);
+          /* packet filtered */
+          return false;
+        }
+
@@ -334,5 +343,24 @@
+void Ipv6RawSocketImpl::SetIfIndex(uint32_t ifIndex)
+{
+  m_ifIndex=ifIndex;
+}
+
+uint32_t Ipv6RawSocketImpl::GetIfIndex()
+{
+  NS_LOG_FUNCTION_NOARGS();
+  return m_ifIndex;
+}
+
+void
+Ipv6RawSocketImpl::SetIcmp6Filter (struct icmp6_filter* filter)
+{
+  NS_LOG_DEBUG("Set filter for " << this);
+  memcpy(&m_icmpFilter, filter, sizeof(struct icmp6_filter));
+  return;
+}
+
--- a/src/internet-stack/ipv6-raw-socket-impl.h	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/internet-stack/ipv6-raw-socket-impl.h	Thu Oct 01 23:37:18 2009 +0900
@@ -26,6 +26,7 @@
+#include <netinet/icmp6.h> // need ICMP6_FILTER
@@ -186,6 +187,10 @@
+    void SetIfIndex(uint32_t ifIndex);
+    uint32_t GetIfIndex();
+    void SetIcmp6Filter (struct icmp6_filter* filter);
+
@@ -246,7 +251,8 @@
-    uint32_t m_icmpFilter;
+    struct icmp6_filter m_icmpFilter;
+    u_int32_t m_ifIndex;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/internet-stack/tcp6-l4-protocol.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,321 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007 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: Raj Bhattacharjea <raj.b@gatech.edu>
+ * 				 Sebastien Vincent <vincent@clarinet.u-strasbg.fr>
+ */
+
+#include "ns3/assert.h"
+#include "ns3/log.h"
+#include "ns3/nstime.h"
+
+#include "ns3/packet.h"
+#include "ns3/node.h"
+
+#include "tcp6-l4-protocol.h"
+#include "tcp-header.h"
+#include "ipv6-end-point-demux.h"
+#include "ipv6-end-point.h"
+#include "ipv6-l3-protocol.h"
+#include "tcp6-socket-impl.h"
+#include "tcp6-socket-factory-impl.h"
+#include "ns3/ipv6-routing-protocol.h"
+#include "ns3/ipv6-route.h"
+
+#include "tcp-typedefs.h"
+
+#include <vector>
+#include <sstream>
+#include <iomanip>
+
+NS_LOG_COMPONENT_DEFINE ("Tcp6L4Protocol");
+
+namespace ns3 {
+
+NS_OBJECT_ENSURE_REGISTERED (Tcp6L4Protocol);
+
+static TcpStateMachine tcpStateMachine; //only instance of a Tcp6StateMachine
+
+//Tcp6L4Protocol stuff----------------------------------------------------------
+
+
+/* see http://www.iana.org/assignments/protocol-numbers */
+const uint8_t Tcp6L4Protocol::PROT_NUMBER = 6;
+
+ObjectFactory
+Tcp6L4Protocol::GetDefaultRttEstimatorFactory (void)
+{
+  ObjectFactory factory;
+  factory.SetTypeId (RttMeanDeviation::GetTypeId ());
+  return factory;
+}
+
+TypeId 
+Tcp6L4Protocol::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::Tcp6L4Protocol")
+    .SetParent<Ipv6L4Protocol> ()
+    .AddConstructor<Tcp6L4Protocol> ()
+    .AddAttribute ("RttEstimatorFactory",
+                   "How RttEstimator objects are created.",
+                   ObjectFactoryValue (GetDefaultRttEstimatorFactory ()),
+                   MakeObjectFactoryAccessor (&Tcp6L4Protocol::m_rttFactory),
+                   MakeObjectFactoryChecker ())
+    ;
+  return tid;
+}
+
+Tcp6L4Protocol::Tcp6L4Protocol ()
+  : m_endPoints (new Ipv6EndPointDemux ())
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_LOGIC("Made a Tcp6L4Protocol "<<this);
+}
+
+Tcp6L4Protocol::~Tcp6L4Protocol ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+}
+
+void 
+Tcp6L4Protocol::SetNode (Ptr<Node> node)
+{
+  m_node = node;
+}
+
+void
+Tcp6L4Protocol::NotifyNewAggregate ()
+{
+  if (m_node == 0)
+    {
+      Ptr<Node> node = this->GetObject<Node> ();
+      if (node != 0)
+        {
+          Ptr<Ipv6L3Protocol> ipv6 = this->GetObject<Ipv6L3Protocol> ();
+          if (ipv6 != 0)
+            {
+              this->SetNode (node);
+              ipv6->Insert (this);
+              Ptr<Tcp6SocketFactoryImpl> tcpFactory = CreateObject<Tcp6SocketFactoryImpl> ();
+              tcpFactory->SetTcp6 (this);
+              node->AggregateObject (tcpFactory);
+            }
+        }
+    }
+  Object::NotifyNewAggregate ();
+}
+
+int 
+Tcp6L4Protocol::GetProtocolNumber (void) const
+{
+  return PROT_NUMBER;
+}
+int 
+Tcp6L4Protocol::GetVersion (void) const
+{
+  return 2;
+}
+
+void
+Tcp6L4Protocol::DoDispose (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  if (m_endPoints != 0)
+    {
+      delete m_endPoints;
+      m_endPoints = 0;
+    }
+  m_node = 0;
+  Ipv6L4Protocol::DoDispose ();
+}
+
+Ptr<Socket>
+Tcp6L4Protocol::CreateSocket (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  Ptr<RttEstimator> rtt = m_rttFactory.Create<RttEstimator> ();
+  Ptr<Tcp6SocketImpl> socket = CreateObject<Tcp6SocketImpl> ();
+  socket->SetNode (m_node);
+  socket->SetTcp (this);
+  socket->SetRtt (rtt);
+  return socket;
+}
+
+Ipv6EndPoint *
+Tcp6L4Protocol::Allocate (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_endPoints->Allocate ();
+}
+
+Ipv6EndPoint *
+Tcp6L4Protocol::Allocate (Ipv6Address address)
+{
+  NS_LOG_FUNCTION (this << address);
+  return m_endPoints->Allocate (address);
+}
+
+Ipv6EndPoint *
+Tcp6L4Protocol::Allocate (uint16_t port)
+{
+  NS_LOG_FUNCTION (this << port);
+  return m_endPoints->Allocate (port);
+}
+
+Ipv6EndPoint *
+Tcp6L4Protocol::Allocate (Ipv6Address address, uint16_t port)
+{
+  NS_LOG_FUNCTION (this << address << port);
+  return m_endPoints->Allocate (address, port);
+}
+
+Ipv6EndPoint *
+Tcp6L4Protocol::Allocate (Ipv6Address localAddress, uint16_t localPort,
+                         Ipv6Address peerAddress, uint16_t peerPort)
+{
+  NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort);
+  return m_endPoints->Allocate (localAddress, localPort,
+                                peerAddress, peerPort);
+}
+
+void 
+Tcp6L4Protocol::DeAllocate (Ipv6EndPoint *endPoint)
+{
+  NS_LOG_FUNCTION (this << endPoint);
+  m_endPoints->DeAllocate (endPoint);
+}
+
+enum Ipv6L4Protocol::RxStatus_e
+Tcp6L4Protocol::Receive (Ptr<Packet> packet,
+             Ipv6Address const &source,
+             Ipv6Address const &destination,
+             Ptr<Ipv6Interface> incomingInterface)
+{
+  NS_LOG_FUNCTION (this << packet << source << destination << incomingInterface);
+
+  TcpHeader tcpHeader;
+
+  tcpHeader.EnableChecksums();
+  //  tcpHeader.InitializeChecksum(source, destination, 6);
+  packet->PeekHeader (tcpHeader);
+
+  NS_LOG_LOGIC("Tcp6L4Protocol " << this
+               << " receiving seq " << tcpHeader.GetSequenceNumber()
+               << " ack " << tcpHeader.GetAckNumber()
+               << " flags "<< std::hex << (int)tcpHeader.GetFlags() << std::dec
+               << " data size " << packet->GetSize());
+ 
+
+  if(!tcpHeader.IsChecksumOk ())
+  {
+    NS_LOG_INFO("Bad checksum, dropping packet!");
+    return Ipv6L4Protocol::RX_CSUM_FAILED;
+  }
+
+  NS_LOG_LOGIC ("Tcp6L4Protocol "<<this<<" received a packet");
+  Ipv6EndPointDemux::EndPoints endPoints =
+    m_endPoints->Lookup (destination, tcpHeader.GetDestinationPort (),
+                         source, tcpHeader.GetSourcePort (),incomingInterface);
+  if (endPoints.empty ())
+  {
+    NS_LOG_LOGIC ("  No endpoints matched on Tcp6L4Protocol "<<this);
+    std::ostringstream oss;
+    oss<<"  destination IP: ";
+    destination.Print (oss);
+    oss<<" destination port: "<< tcpHeader.GetDestinationPort ()<<" source IP: ";
+    source.Print (oss);
+    oss<<" source port: "<<tcpHeader.GetSourcePort ();
+    NS_LOG_LOGIC (oss.str ());
+    return Ipv6L4Protocol::RX_ENDPOINT_UNREACH;
+  }
+  NS_ASSERT_MSG (endPoints.size() == 1 , "Demux returned more than one endpoint");
+  NS_LOG_LOGIC ("Tcp6L4Protocol "<<this<<" forwarding up to endpoint/socket");
+  (*endPoints.begin ())->ForwardUp (packet, source, tcpHeader.GetSourcePort ());
+  return Ipv6L4Protocol::RX_OK;
+}
+
+void
+Tcp6L4Protocol::Send (Ptr<Packet> packet, 
+           Ipv6Address saddr, Ipv6Address daddr, 
+           uint16_t sport, uint16_t dport)
+{
+  NS_LOG_FUNCTION (this << packet << saddr << daddr << sport << dport);
+
+  TcpHeader tcpHeader;
+  tcpHeader.SetDestinationPort (dport);
+  tcpHeader.SetSourcePort (sport);
+	tcpHeader.SetLength(5);
+  tcpHeader.EnableChecksums();
+//   tcpHeader.InitializeChecksum (saddr,
+//                                daddr,
+//                                PROT_NUMBER);
+  tcpHeader.SetFlags (TcpHeader::ACK);
+  tcpHeader.SetAckNumber (0);
+
+  packet->AddHeader (tcpHeader);
+
+  Ptr<Ipv6L3Protocol> ipv6 = 
+    m_node->GetObject<Ipv6L3Protocol> ();
+  if (ipv6 != 0)
+    {
+      Ipv6Header header;
+      header.SetDestinationAddress (daddr);
+      Socket::SocketErrno errno_;
+      Ptr<Ipv6Route> route;
+      uint32_t oif = 0; //specify non-zero if bound to a source address
+      route = ipv6->GetRoutingProtocol ()->RouteOutput (packet, header, oif, errno_);
+      ipv6->Send (packet, saddr, daddr, PROT_NUMBER, route);
+    }
+}
+
+void
+Tcp6L4Protocol::SendPacket (Ptr<Packet> packet, TcpHeader outgoingHeader,
+                               Ipv6Address saddr, Ipv6Address daddr)
+{
+  NS_LOG_LOGIC("TcpL4Protocol " << this
+              << " sending seq " << outgoingHeader.GetSequenceNumber()
+              << " ack " << outgoingHeader.GetAckNumber()
+              << " flags " << std::hex << (int)outgoingHeader.GetFlags() << std::dec
+              << " data size " << packet->GetSize());
+  NS_LOG_FUNCTION (this << packet << saddr << daddr);
+  // XXX outgoingHeader cannot be logged
+
+  outgoingHeader.SetLength (5); //header length in units of 32bit words
+  /* outgoingHeader.SetUrgentPointer (0); //XXX */
+  outgoingHeader.EnableChecksums();
+  //  outgoingHeader.InitializeChecksum(saddr, daddr, PROT_NUMBER);
+
+  packet->AddHeader (outgoingHeader);
+
+  Ptr<Ipv6L3Protocol> ipv6 = 
+    m_node->GetObject<Ipv6L3Protocol> ();
+  if (ipv6 != 0)
+    {
+      Ipv6Header header;
+      header.SetDestinationAddress (daddr);
+      Socket::SocketErrno errno_;
+      Ptr<Ipv6Route> route;
+      uint32_t oif = 0; //specify non-zero if bound to a source address
+      route = ipv6->GetRoutingProtocol ()->RouteOutput (packet, header, oif, errno_);
+      ipv6->Send (packet, saddr, daddr, PROT_NUMBER, route);
+    }
+  else
+    NS_FATAL_ERROR("Trying to use Tcp on a node without an Ipv6 interface");
+}
+
+}; // namespace ns3
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/internet-stack/tcp6-l4-protocol.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,121 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007 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: Raj Bhattacharjea <raj.b@gatech.edu>
+ * 				 Sebastien Vincent <vincent@clarinet.u-strasbg.fr>
+ */
+
+#ifndef TCP6_L4_PROTOCOL_H
+#define TCP6_L4_PROTOCOL_H
+
+#include <stdint.h>
+
+#include "ns3/packet.h"
+#include "ns3/ipv6-address.h"
+#include "ns3/ptr.h"
+#include "ns3/object-factory.h"
+#include "ipv6-end-point-demux.h"
+#include "ipv6-l4-protocol.h"
+#include "ipv6-interface.h"
+
+#include "tcp-header.h"
+#include "tcp-typedefs.h"
+
+namespace ns3 {
+
+class Node;
+class Socket;
+class TcpHeader;
+/**
+ * \class Tcp6L4Protocol
+ * \brief Implementation of the TCP protocol
+ */
+class Tcp6L4Protocol : public Ipv6L4Protocol {
+public:
+  static TypeId GetTypeId (void);
+  static const uint8_t PROT_NUMBER;
+  /**
+   * \brief Constructor
+   */
+  Tcp6L4Protocol ();
+  virtual ~Tcp6L4Protocol ();
+
+  void SetNode (Ptr<Node> node);
+
+  virtual int GetProtocolNumber (void) const;
+  virtual int GetVersion (void) const;
+
+  /**
+   * \return A smart Socket pointer to a Tcp6SocketImpl, allocated by this instance
+   * of the TCP protocol
+   */
+  Ptr<Socket> CreateSocket (void);
+
+  Ipv6EndPoint *Allocate (void);
+  Ipv6EndPoint *Allocate (Ipv6Address address);
+  Ipv6EndPoint *Allocate (uint16_t port);
+  Ipv6EndPoint *Allocate (Ipv6Address address, uint16_t port);
+  Ipv6EndPoint *Allocate (Ipv6Address localAddress, uint16_t localPort,
+                          Ipv6Address peerAddress, uint16_t peerPort);
+
+  void DeAllocate (Ipv6EndPoint *endPoint);
+
+//   // called by Tcp6SocketImpl.
+//   bool Connect (const Ipv6Address& saddr, const Ipv6Address& daddr,
+//                 uint16_t sport, uint16_t dport);
+
+  /**
+   * \brief Send a packet via TCP
+   * \param packet The packet to send
+   * \param saddr The source Ipv6Address
+   * \param daddr The destination Ipv6Address
+   * \param sport The source port number
+   * \param dport The destination port number
+   */
+  void Send (Ptr<Packet> packet,
+             Ipv6Address saddr, Ipv6Address daddr, 
+             uint16_t sport, uint16_t dport);
+  /**
+   * \brief Recieve a packet up the protocol stack
+   * \param p The Packet to dump the contents into
+   * \param source The source's Ipv6Address
+   * \param destination The destinations Ipv6Address
+   * \param incomingInterface The Ipv6Interface it was received on
+   */
+  virtual enum Ipv6L4Protocol::RxStatus_e Receive (Ptr<Packet> p,
+                       Ipv6Address const &source,
+                       Ipv6Address const &destination,
+                       Ptr<Ipv6Interface> incomingInterface);
+
+protected:
+  virtual void DoDispose (void);
+  virtual void NotifyNewAggregate ();
+private:
+  Ptr<Node> m_node;
+  Ipv6EndPointDemux *m_endPoints;
+  ObjectFactory m_rttFactory;
+private:
+  friend class Tcp6SocketImpl;
+  void SendPacket (Ptr<Packet>, TcpHeader,
+                  Ipv6Address, Ipv6Address);
+  static ObjectFactory GetDefaultRttEstimatorFactory (void);
+};
+
+}; // namespace ns3
+
+#endif /* TCP6_L4_PROTOCOL_H */
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/internet-stack/tcp6-socket-factory-impl.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,56 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007-2008 Louis Pasteur University
+ *
+ * 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: David Gross <gdavid.devel@gmail.com>
+ */
+
+#include "tcp6-socket-factory-impl.h"
+#include "tcp6-l4-protocol.h"
+#include "ns3/socket.h"
+#include "ns3/assert.h"
+
+namespace ns3 
+{
+
+	Tcp6SocketFactoryImpl::Tcp6SocketFactoryImpl ()
+		: m_tcp6 (0)
+	{
+	}
+
+	Tcp6SocketFactoryImpl::~Tcp6SocketFactoryImpl ()
+	{
+		NS_ASSERT (m_tcp6 == 0);
+	}
+
+	void Tcp6SocketFactoryImpl::SetTcp6 (Ptr<Tcp6L4Protocol> tcp6)
+	{
+		m_tcp6 = tcp6;
+	}
+
+	Ptr<Socket> Tcp6SocketFactoryImpl::CreateSocket ()
+	{
+		return m_tcp6->CreateSocket ();
+	}
+
+	void Tcp6SocketFactoryImpl::DoDispose (void)
+	{
+		m_tcp6 = 0;
+		Tcp6SocketFactory::DoDispose ();
+	}
+
+} /* namespace ns3 */
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/internet-stack/tcp6-socket-factory-impl.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,81 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007-2008 Louis Pasteur University
+ *
+ * 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 : David Gross <gdavid.devel@gmail.com>
+ */
+
+#ifndef TCP6_SOCKET_FACTORY_IMPL_H
+#define TCP6_SOCKET_FACTORY_IMPL_H
+
+#include "ns3/tcp6-socket-factory.h"
+#include "ns3/ptr.h"
+
+namespace ns3 
+{
+
+	class Socket;
+	class Tcp6L4Protocol;
+
+	/**
+	 * \class Tcp6SocketFactoryImpl
+	 * \brief TCPv6 socket factory implementation.
+	 * \section Tcp overview
+	 * This TCP over IPv6 version is ported from IPv4 code.
+	 */
+
+	class Tcp6SocketFactoryImpl : public Tcp6SocketFactory
+	{
+		public:
+			/**
+			 * \brief Constructor.
+			 */
+			Tcp6SocketFactoryImpl ();
+
+			/**
+			 * \brief Destructor.
+			 */
+			virtual ~Tcp6SocketFactoryImpl ();
+
+			/**
+			 * \brief Set the TCPv6 Protocol.
+			 * \param tcp6 the TCPv6 protocol
+			 */
+			void SetTcp6 (Ptr<Tcp6L4Protocol> tcp6);
+
+			/**
+			 * \brief Create a socket.
+			 * \return pointer on a socket.
+			 */
+			virtual Ptr<Socket> CreateSocket ();
+
+		protected:
+			/**
+			 * \brief Dispose this object.
+			 */
+			virtual void DoDispose (void);
+
+		private:
+			/**
+			 * \brief The Tcp6L4Protocol instance.
+			 */
+			Ptr<Tcp6L4Protocol> m_tcp6;
+	};
+
+} /* namespace ns3 */
+
+#endif /* TCP6_SOCKET_FACTORY_IMPL_H */
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/internet-stack/tcp6-socket-impl.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,1482 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007 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: Raj Bhattacharjea <raj.b@gatech.edu>
+ * 				 Sebastien Vincent <vincent@clarinet.u-strasbg.fr>
+ */
+
+#include "ns3/node.h"
+#include "ns3/inet6-socket-address.h"
+#include "ns3/log.h"
+#include "ns3/ipv6.h"
+#include "tcp6-socket-impl.h"
+#include "tcp6-l4-protocol.h"
+#include "ipv6-end-point.h"
+#include "ns3/simulation-singleton.h"
+#include "tcp-typedefs.h"
+#include "ns3/simulator.h"
+#include "ns3/packet.h"
+#include "ns3/uinteger.h"
+#include "ns3/trace-source-accessor.h"
+#include "ns3/ipv6-header.h"
+#include "ns3/ipv6-route.h"
+#include "ns3/ipv6-routing-protocol.h"
+
+#include <algorithm>
+
+NS_LOG_COMPONENT_DEFINE ("Tcp6SocketImpl");
+
+using namespace std;
+
+namespace ns3 {
+
+NS_OBJECT_ENSURE_REGISTERED (Tcp6SocketImpl);
+
+TypeId
+Tcp6SocketImpl::GetTypeId ()
+{
+  static TypeId tid = TypeId("ns3::Tcp6SocketImpl")
+    .SetParent<TcpSocket> ()
+    .AddTraceSource ("CongestionWindow",
+                     "The TCP connection's congestion window",
+                     MakeTraceSourceAccessor (&Tcp6SocketImpl::m_cWnd))
+    ;
+  return tid;
+}
+
+  Tcp6SocketImpl::Tcp6SocketImpl ()
+  : m_skipRetxResched (false),
+    m_dupAckCount (0),
+    m_delAckCount (0),
+    m_endPoint (0),
+    m_node (0),
+    m_tcp (0),
+    m_errno (ERROR_NOTERROR),
+    m_shutdownSend (false),
+    m_shutdownRecv (false),
+    m_connected (false),
+    m_state (CLOSED),
+    m_closeNotified (false),
+    m_closeRequestNotified (false),
+    m_closeOnEmpty (false),
+    m_pendingClose (false),
+    m_nextTxSequence (0),
+    m_highTxMark (0),
+    m_highestRxAck (0),
+    m_lastRxAck (0),
+    m_nextRxSequence (0),
+    m_pendingData (0),
+    m_rtt (0),
+    m_lastMeasuredRtt (Seconds(0.0)),
+    m_rxAvailable (0), 
+    m_wouldBlock (false) 
+{
+  NS_LOG_FUNCTION (this);
+}
+
+Tcp6SocketImpl::Tcp6SocketImpl(const Tcp6SocketImpl& sock)
+  : TcpSocket(sock), //copy the base class callbacks
+    m_skipRetxResched (sock.m_skipRetxResched),
+    m_dupAckCount (sock.m_dupAckCount),
+    m_delAckCount (0),
+    m_delAckMaxCount (sock.m_delAckMaxCount),
+    m_delAckTimeout (sock.m_delAckTimeout),
+    m_endPoint (0),
+    m_node (sock.m_node),
+    m_tcp (sock.m_tcp),
+    m_remoteAddress (sock.m_remoteAddress),
+    m_remotePort (sock.m_remotePort),
+    m_localAddress (sock.m_localAddress),
+    m_localPort (sock.m_localPort),
+    m_errno (sock.m_errno),
+    m_shutdownSend (sock.m_shutdownSend),
+    m_shutdownRecv (sock.m_shutdownRecv),
+    m_connected (sock.m_connected),
+    m_state (sock.m_state),
+    m_closeNotified (sock.m_closeNotified),
+    m_closeRequestNotified (sock.m_closeRequestNotified),
+    m_closeOnEmpty (sock.m_closeOnEmpty),
+    m_pendingClose (sock.m_pendingClose),
+    m_nextTxSequence (sock.m_nextTxSequence),
+    m_highTxMark (sock.m_highTxMark),
+    m_highestRxAck (sock.m_highestRxAck),
+    m_lastRxAck (sock.m_lastRxAck),
+    m_nextRxSequence (sock.m_nextRxSequence),
+    m_pendingData (0),
+    m_segmentSize (sock.m_segmentSize),
+    m_rxWindowSize (sock.m_rxWindowSize),
+    m_advertisedWindowSize (sock.m_advertisedWindowSize),
+    m_cWnd (sock.m_cWnd),
+    m_ssThresh (sock.m_ssThresh),
+    m_initialCWnd (sock.m_initialCWnd),
+    m_rtt (0),
+    m_lastMeasuredRtt (Seconds(0.0)),
+    m_cnTimeout (sock.m_cnTimeout),
+    m_cnCount (sock.m_cnCount),
+    m_rxAvailable (0),
+    m_wouldBlock (false),
+    m_sndBufSize (sock.m_sndBufSize),
+    m_rcvBufSize(sock.m_rcvBufSize)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_LOGIC("Invoked the copy constructor");
+  //copy the pending data if necessary
+  if(sock.m_pendingData)
+    {
+      m_pendingData = sock.m_pendingData->Copy();
+    }
+  //copy the rtt if necessary
+  if (sock.m_rtt)
+    {
+      m_rtt = sock.m_rtt->Copy();
+    }
+  //can't "copy" the endpoint just yes, must do this when we know the peer info
+  //too; this is in SYN_ACK_TX
+}
+
+Tcp6SocketImpl::~Tcp6SocketImpl ()
+{
+  NS_LOG_FUNCTION(this);
+  m_node = 0;
+  if (m_endPoint != 0)
+    {
+      NS_ASSERT (m_tcp != 0);
+      /**
+       * Note that this piece of code is a bit tricky:
+       * when DeAllocate is called, it will call into
+       * Ipv6EndPointDemux::Deallocate which triggers
+       * a delete of the associated endPoint which triggers
+       * in turn a call to the method ::Destroy below
+       * will will zero the m_endPoint field.
+       */
+      NS_ASSERT (m_endPoint != 0);
+      m_tcp->DeAllocate (m_endPoint);
+      NS_ASSERT (m_endPoint == 0);
+    }
+  m_tcp = 0;
+  delete m_pendingData; //prevents leak
+  m_pendingData = 0;
+}
+
+void
+Tcp6SocketImpl::SetNode (Ptr<Node> node)
+{
+  m_node = node;
+  // Initialize some variables 
+  m_cWnd = m_initialCWnd * m_segmentSize;
+  m_rxWindowSize = m_advertisedWindowSize;
+}
+
+void 
+Tcp6SocketImpl::SetTcp (Ptr<Tcp6L4Protocol> tcp)
+{
+  m_tcp = tcp;
+}
+void 
+Tcp6SocketImpl::SetRtt (Ptr<RttEstimator> rtt)
+{
+  m_rtt = rtt;
+}
+
+
+enum Socket::SocketErrno
+Tcp6SocketImpl::GetErrno (void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_errno;
+}
+
+Ptr<Node>
+Tcp6SocketImpl::GetNode (void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_node;
+}
+
+void 
+Tcp6SocketImpl::Destroy (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  m_node = 0;
+  m_endPoint = 0;
+  m_tcp = 0;
+  m_retxEvent.Cancel ();
+}
+int
+Tcp6SocketImpl::FinishBind (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  if (m_endPoint == 0)
+    {
+      return -1;
+    }
+  m_endPoint->SetRxCallback (MakeCallback (&Tcp6SocketImpl::ForwardUp, Ptr<Tcp6SocketImpl>(this)));
+  m_endPoint->SetDestroyCallback (MakeCallback (&Tcp6SocketImpl::Destroy, Ptr<Tcp6SocketImpl>(this)));
+  m_localAddress = m_endPoint->GetLocalAddress ();
+  m_localPort = m_endPoint->GetLocalPort ();
+  return 0;
+}
+
+int
+Tcp6SocketImpl::Bind (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  m_endPoint = m_tcp->Allocate ();
+  return FinishBind ();
+}
+int 
+Tcp6SocketImpl::Bind (const Address &address)
+{
+  NS_LOG_FUNCTION (this<<address);
+  if (!Inet6SocketAddress::IsMatchingType (address))
+    {
+      return ERROR_INVAL;
+    }
+  Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);
+  Ipv6Address ipv6 = transport.GetIpv6 ();
+  uint16_t port = transport.GetPort ();
+  if (ipv6 == Ipv6Address::GetAny () && port == 0)
+    {
+      m_endPoint = m_tcp->Allocate ();
+      NS_LOG_LOGIC ("Tcp6SocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
+    }
+  else if (ipv6 == Ipv6Address::GetAny () && port != 0)
+    {
+      m_endPoint = m_tcp->Allocate (port);
+      NS_LOG_LOGIC ("Tcp6SocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
+    }
+  else if (ipv6 != Ipv6Address::GetAny () && port == 0)
+    {
+      m_endPoint = m_tcp->Allocate (ipv6);
+      NS_LOG_LOGIC ("Tcp6SocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
+    }
+  else if (ipv6 != Ipv6Address::GetAny () && port != 0)
+    {
+      m_endPoint = m_tcp->Allocate (ipv6, port);
+      NS_LOG_LOGIC ("Tcp6SocketImpl "<<this<<" got an endpoint: "<<m_endPoint);
+    }
+
+  return FinishBind ();
+}
+
+int 
+Tcp6SocketImpl::ShutdownSend (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  m_shutdownSend = true;
+  return 0;
+}
+int 
+Tcp6SocketImpl::ShutdownRecv (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  m_shutdownRecv = false;
+  return 0;
+}
+
+int
+Tcp6SocketImpl::Close (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  if (m_state == CLOSED) 
+    {
+      return -1;
+    }
+  if (m_pendingData && m_pendingData->Size() != 0)
+    { // App close with pending data must wait until all data transmitted
+      m_closeOnEmpty = true;
+      NS_LOG_LOGIC("Socket " << this << 
+                   " deferring close, state " << m_state);
+      return 0;
+    }
+
+  Actions_t action  = ProcessEvent (APP_CLOSE);
+  ProcessAction (action);
+  ShutdownSend ();
+  return 0;
+}
+
+int
+Tcp6SocketImpl::Connect (const Address & address)
+{
+  NS_LOG_FUNCTION (this << address);
+  if (m_endPoint == 0)
+    {
+      if (Bind () == -1)
+        {
+          NS_ASSERT (m_endPoint == 0);
+          return -1;
+        }
+      NS_ASSERT (m_endPoint != 0);
+    }
+  Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);
+  m_remoteAddress = transport.GetIpv6 ();
+  m_remotePort = transport.GetPort ();
+  
+  Ptr<Ipv6> ipv6 = m_node->GetObject<Ipv6> ();
+
+  Ipv6Header header;
+  header.SetDestinationAddress (m_remoteAddress);
+  Socket::SocketErrno errno_;
+  Ptr<Ipv6Route> route;
+  uint32_t oif = 0; //specify non-zero if bound to a source address
+  // XXX here, cache the route in the endpoint?
+  route = ipv6->GetRoutingProtocol ()->RouteOutput (Ptr<Packet> (), header, oif, errno_);
+
+  if (route != 0)
+    {
+      m_endPoint->SetLocalAddress (route->GetSource ());
+    }
+  else
+    {
+      m_errno = ERROR_NOROUTETOHOST;
+      return -1;
+    }
+
+  Actions_t action = ProcessEvent (APP_CONNECT);
+  bool success = ProcessAction (action);
+  if (success) 
+    {
+      return 0;
+    }
+  return -1;
+}
+int 
+Tcp6SocketImpl::Send (Ptr<Packet> p, uint32_t flags) 
+{
+  NS_LOG_FUNCTION (this << p);
+  if (m_state == ESTABLISHED || m_state == SYN_SENT || m_state == CLOSE_WAIT)
+  {
+    if (p->GetSize() > GetTxAvailable ())
+    {
+      m_wouldBlock = true;
+      m_errno = ERROR_MSGSIZE;
+      return -1;
+    }
+    if (!m_pendingData)
+    {
+      m_pendingData = new PendingData ();   // Create if non-existent
+      m_firstPendingSequence = m_nextTxSequence; // Note seq of first
+    }
+    //PendingData::Add stores a copy of the Ptr p
+    m_pendingData->Add (p);
+    NS_LOG_DEBUG("TcpSock::Send, pdsize " << m_pendingData->Size() << 
+        " state " << m_state);
+    Actions_t action = ProcessEvent (APP_SEND);
+    NS_LOG_DEBUG(" action " << action);
+    if (!ProcessAction (action)) 
+    {
+      return -1; // Failed, return zero
+    }
+    return p->GetSize();
+  }
+  else
+  {
+    m_errno = ERROR_NOTCONN;
+    return -1;
+  }
+}
+
+int Tcp6SocketImpl::DoSendTo (Ptr<Packet> p, const Address &address)
+{
+  NS_LOG_FUNCTION (this << p << address);
+  Inet6SocketAddress transport = Inet6SocketAddress::ConvertFrom (address);
+  Ipv6Address ipv6 = transport.GetIpv6 ();
+  uint16_t port = transport.GetPort ();
+  return DoSendTo (p, ipv6, port);
+}
+
+int Tcp6SocketImpl::DoSendTo (Ptr<Packet> p, Ipv6Address ipv6, uint16_t port)
+{
+  NS_LOG_FUNCTION (this << p << ipv6 << port);
+  if (m_endPoint == 0)
+    {
+      if (Bind () == -1)
+	{
+          NS_ASSERT (m_endPoint == 0);
+	  return -1;
+	}
+      NS_ASSERT (m_endPoint != 0);
+    }
+  if (m_shutdownSend)
+    {
+      m_errno = ERROR_SHUTDOWN;
+      return -1;
+    }
+  m_tcp->Send (p, m_endPoint->GetLocalAddress (), ipv6,
+                  m_endPoint->GetLocalPort (), port);
+  NotifyDataSent (p->GetSize ());
+  return 0;
+}
+
+int 
+Tcp6SocketImpl::SendTo (Ptr<Packet> p, uint32_t flags, const Address &address)
+{
+  NS_LOG_FUNCTION (this << address << p);
+  if (!m_connected)
+    {
+      m_errno = ERROR_NOTCONN;
+      return -1;
+    }
+  else
+    {
+      return Send (p, flags); //drop the address according to BSD manpages
+    }
+}
+
+uint32_t
+Tcp6SocketImpl::GetTxAvailable (void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  if (m_pendingData != 0)
+    {
+      uint32_t unAckedDataSize = 
+        m_pendingData->SizeFromSeq (m_firstPendingSequence, m_highestRxAck);
+      NS_ASSERT (m_sndBufSize >= unAckedDataSize); //else a logical error
+      return m_sndBufSize-unAckedDataSize;
+    }
+  else
+    {
+      return m_sndBufSize;
+    }
+}
+
+int
+Tcp6SocketImpl::Listen ()
+{
+  NS_LOG_FUNCTION (this);
+  Actions_t action = ProcessEvent (APP_LISTEN);
+  ProcessAction (action);
+  return 0;
+}
+
+Ptr<Packet>
+Tcp6SocketImpl::Recv (uint32_t maxSize, uint32_t flags)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  if(m_bufferedData.empty())
+    {
+      return 0;
+    }
+  UnAckData_t out; //serves as buffer to return up to the user
+  UnAckData_t::iterator i;
+  while (!m_bufferedData.empty ())
+    { // Check the buffered data for delivery
+      NS_LOG_LOGIC("TCP " << this << " bufferedData.size() " 
+        << m_bufferedData.size () 
+        << " time " << Simulator::Now ());
+      i = m_bufferedData.begin ();
+      SequenceNumber s1 = 0;
+      if (i->first > m_nextRxSequence) 
+        {
+          break;  // we're done, no more in-sequence data exits
+        }
+      else // (i->first <= m_nextRxSequence)
+        { // Two cases here.
+          // 1) seq + length > nextRxSeq, can deliver partial
+          // 2) seq + length <= nextRxSeq, deliver whole
+          s1 = i->second->GetSize ();
+          if (i->first + s1 > m_nextRxSequence)
+            { // Remove partial data to prepare for delivery
+              uint32_t avail = s1 + i->first - m_nextRxSequence;
+              i->second = i->second->CreateFragment (0, avail);
+            }
+          // else this packet is okay to deliver whole
+          // so don't do anything else and output it
+          out[i->first]  = i->second;
+        }
+      m_rxAvailable -= i->second->GetSize ();
+      m_bufferedData.erase (i);     // Remove from list
+    }
+  if (out.size() == 0)
+    {
+      return 0;
+    }
+  Ptr<Packet> outPacket = Create<Packet>();
+  for(i = out.begin(); i!=out.end(); ++i)
+  {
+    if (outPacket->GetSize() + i->second->GetSize() <= maxSize )
+    {
+      outPacket->AddAtEnd(i->second);
+    }
+    else
+    {
+      //only append as much as will fit
+      uint32_t avail = maxSize - outPacket->GetSize();
+      outPacket->AddAtEnd(i->second->CreateFragment(0,avail));
+      //put the rest back into the buffer
+      m_bufferedData[i->first+SequenceNumber(avail)] 
+          = i->second->CreateFragment(avail,i->second->GetSize()-avail);
+      m_rxAvailable += i->second->GetSize()-avail;
+    }
+  }
+  return outPacket;
+}
+
+uint32_t
+Tcp6SocketImpl::GetRxAvailable (void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  // We separately maintain this state to avoid walking the queue 
+  // every time this might be called
+  return m_rxAvailable;
+}
+
+Ptr<Packet> Tcp6SocketImpl::RecvFrom (uint32_t maxSize, uint32_t flags,
+ Address &fromAddress)
+{
+	NS_LOG_FUNCTION (this << maxSize << flags);
+	Ptr<Packet> packet = Recv (maxSize, flags);
+	if (packet != 0)
+	{
+		SocketAddressTag tag;
+		bool found;
+		found = packet->FindFirstMatchingByteTag (tag);
+		NS_ASSERT (found);
+		fromAddress = tag.GetAddress ();
+	}
+	return packet;
+} 
+
+void
+Tcp6SocketImpl::ForwardUp (Ptr<Packet> packet, Ipv6Address ipv6, uint16_t port)
+{
+  NS_LOG_DEBUG("Socket " << this << " got forward up" <<
+               " dport " << m_endPoint->GetLocalPort() <<
+               " daddr " << m_endPoint->GetLocalAddress() <<
+               " sport " << m_endPoint->GetPeerPort() <<
+               " saddr " << m_endPoint->GetPeerAddress());
+
+  NS_LOG_FUNCTION (this << packet << ipv6 << port);
+  if (m_shutdownRecv)
+    {
+      return;
+    }
+  TcpHeader tcpHeader;
+  packet->RemoveHeader (tcpHeader);
+
+  if (tcpHeader.GetFlags () & TcpHeader::ACK)
+    {
+      Time m = m_rtt->AckSeq (tcpHeader.GetAckNumber () );
+      if (m != Seconds (0.0))
+        {
+          m_lastMeasuredRtt = m;
+        }
+    }
+
+  Events_t event = SimulationSingleton<TcpStateMachine>::Get ()->FlagsEvent (tcpHeader.GetFlags () );
+  Actions_t action = ProcessEvent (event); //updates the state
+  Address address = Inet6SocketAddress (ipv6, port);
+  NS_LOG_DEBUG("Socket " << this << 
+               " processing pkt action, " << action <<
+               " current state " << m_state);
+  ProcessPacketAction (action, packet, tcpHeader, address);
+}
+
+Actions_t Tcp6SocketImpl::ProcessEvent (Events_t e)
+{
+  NS_LOG_FUNCTION (this << e);
+  States_t saveState = m_state;
+  NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " processing event " << e);
+  // simulation singleton is a way to get a single global static instance of a
+  // class intended to be a singleton; see simulation-singleton.h
+  SA stateAction = SimulationSingleton<TcpStateMachine>::Get ()->Lookup (m_state,e);
+  // debug
+  if (stateAction.action == RST_TX)
+    {
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " sending RST from state "
+              << saveState << " event " << e);
+    }
+  bool needCloseNotify = (stateAction.state == CLOSED && m_state != CLOSED 
+    && e != TIMEOUT);
+  m_state = stateAction.state;
+  NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " moved from state " << saveState 
+    << " to state " <<m_state);
+  NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " pendingData " << m_pendingData);
+
+  //extra event logic is here for RX events
+  //e = SYN_ACK_RX
+  if (saveState == SYN_SENT && m_state == ESTABLISHED)
+    // this means the application side has completed its portion of 
+    // the handshaking
+    {
+      Simulator::ScheduleNow(&Tcp6SocketImpl::ConnectionSucceeded, this);
+      //NotifyConnectionSucceeded ();
+      m_connected = true;
+      m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " Connected!");
+    }
+
+  if (needCloseNotify && !m_closeNotified)
+    {
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " transition to CLOSED from " 
+               << m_state << " event " << e << " closeNot " << m_closeNotified
+               << " action " << stateAction.action);
+      m_closeNotified = true;
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " calling Closed from PE"
+              << " origState " << saveState
+              << " event " << e);
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " transition to CLOSED from "
+          << m_state << " event " << e
+          << " set CloseNotif ");
+    }
+  return stateAction.action;
+}
+
+void Tcp6SocketImpl::SendEmptyPacket (uint8_t flags)
+{
+  NS_LOG_FUNCTION (this << flags);
+  Ptr<Packet> p = Create<Packet> ();
+  TcpHeader header;
+
+  header.SetFlags (flags);
+  header.SetSequenceNumber (m_nextTxSequence);
+  header.SetAckNumber (m_nextRxSequence);
+  header.SetSourcePort (m_endPoint->GetLocalPort ());
+  header.SetDestinationPort (m_remotePort);
+  header.SetWindowSize (m_advertisedWindowSize);
+  m_tcp->SendPacket (p, header, m_endPoint->GetLocalAddress (), 
+    m_remoteAddress);
+  Time rto = m_rtt->RetransmitTimeout ();
+  if (flags & TcpHeader::SYN)
+    {
+      rto = m_cnTimeout;
+      m_cnTimeout = m_cnTimeout + m_cnTimeout;
+      m_cnCount--;
+    }
+  if (m_retxEvent.IsExpired () ) //no outstanding timer
+  {
+    NS_LOG_LOGIC ("Schedule retransmission timeout at time " 
+          << Simulator::Now ().GetSeconds () << " to expire at time " 
+          << (Simulator::Now () + rto).GetSeconds ());
+    m_retxEvent = Simulator::Schedule (rto, &Tcp6SocketImpl::ReTxTimeout, this);
+  }
+}
+
+bool Tcp6SocketImpl::ProcessAction (Actions_t a)
+{ // These actions do not require a packet or any TCP Headers
+  NS_LOG_FUNCTION (this << a);
+  switch (a)
+  {
+    case NO_ACT:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action: NO_ACT");
+      break;
+    case ACK_TX:
+      SendEmptyPacket (TcpHeader::ACK);
+      break;
+    case ACK_TX_1:
+      NS_ASSERT (false); // This should be processed in ProcessPacketAction
+      break;
+    case RST_TX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action RST_TX");
+      SendEmptyPacket (TcpHeader::RST);
+      break;
+    case SYN_TX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action SYN_TX");
+      // TCP SYN Flag consumes one byte
+      // is the above correct? we're SENDING a syn, not acking back -- Raj
+      // commented out for now
+      // m_nextTxSequence+= 1;
+      SendEmptyPacket (TcpHeader::SYN);
+      break;
+    case SYN_ACK_TX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action SYN_ACK_TX");
+      // TCP SYN Flag consumes one byte
+      ++m_nextRxSequence;
+      SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
+      break;
+    case FIN_TX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action FIN_TX");
+      SendEmptyPacket (TcpHeader::FIN);
+      break;
+    case FIN_ACK_TX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action FIN_ACK_TX");
+      SendEmptyPacket (TcpHeader::FIN | TcpHeader::ACK);
+      break;
+    case NEW_ACK:
+      NS_ASSERT (false); // This should be processed in ProcessPacketAction
+      break;
+    case NEW_SEQ_RX:
+      NS_ASSERT (false); // This should be processed in ProcessPacketAction
+      break;
+    case RETX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action RETX");
+      break;
+    case TX_DATA:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action TX_DATA");
+      SendPendingData ();
+      break;
+    case PEER_CLOSE:
+      NS_ASSERT (false); // This should be processed in ProcessPacketAction
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action PEER_CLOSE");
+      break;
+    case APP_CLOSED:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action APP_CLOSED");
+      break;
+    case CANCEL_TM:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action CANCEL_TM");
+      break;
+    case APP_NOTIFY:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action APP_NOTIFY");
+      break;
+    case SERV_NOTIFY:
+      NS_ASSERT (false); // This should be processed in ProcessPacketAction
+      break;
+    case LAST_ACTION:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action LAST_ACTION");
+      break;
+  }
+  return true;
+}
+
+bool Tcp6SocketImpl::ProcessPacketAction (Actions_t a, Ptr<Packet> p,
+                                     const TcpHeader& tcpHeader,
+                                     const Address& fromAddress)
+{
+  NS_LOG_FUNCTION (this << a << p  << fromAddress);
+  Ipv6Header header;
+  Socket::SocketErrno errno_;
+  Ptr<Ipv6Route> route;
+  uint32_t oif = 0;
+
+  Ptr<Ipv6> ipv6 = m_node->GetObject<Ipv6> ();
+  switch (a)
+  {
+    case SYN_ACK_TX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action SYN_ACK_TX");
+//      m_remotePort = Inet6SocketAddress::ConvertFrom (fromAddress).GetPort ();
+//      m_remoteAddress = Inet6SocketAddress::ConvertFrom (fromAddress).GetIpv6 ();
+//       if (ipv6->GetIfIndexForDestination (m_remoteAddress, localIfIndex))
+//         {
+//           m_localAddress = ipv6->GetAddress (localIfIndex);
+//         }
+      if (m_state == LISTEN) //this means we should fork a new Tcp6SocketImpl
+        {
+          NS_LOG_DEBUG("In SYN_ACK_TX, m_state is LISTEN, this " << this);
+          //notify the server that we got a SYN
+          // If server refuses connection do nothing
+          if (!NotifyConnectionRequest(fromAddress)) return true;
+          // Clone the socket
+          Ptr<Tcp6SocketImpl> newSock = Copy ();
+          NS_LOG_LOGIC ("Cloned a Tcp6SocketImpl " << newSock);
+          //this listening socket should do nothing more
+          Simulator::ScheduleNow (&Tcp6SocketImpl::CompleteFork, newSock,
+                                  p, tcpHeader,fromAddress);
+          return true;
+        }
+        // This is the cloned endpoint
+        m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
+
+        header.SetDestinationAddress (m_remoteAddress);
+        oif = 0; //specify non-zero if bound to a source address
+        route = ipv6->GetRoutingProtocol ()->RouteOutput (Ptr<Packet> (), header, oif, errno_);
+
+        if (route != 0)
+          {
+            m_endPoint->SetLocalAddress (route->GetSource());
+            // Leave local addr in the portmap to any, as the path from
+            // remote can change and packets can arrive on different interfaces
+            //m_endPoint->SetLocalAddress (Ipv6Address::GetAny());
+          }
+        // TCP SYN consumes one byte
+        m_nextRxSequence = tcpHeader.GetSequenceNumber() + SequenceNumber(1);
+        SendEmptyPacket (TcpHeader::SYN | TcpHeader::ACK);
+      break;
+    case ACK_TX_1:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action ACK_TX_1");
+      // TCP SYN consumes one byte
+      m_nextRxSequence = tcpHeader.GetSequenceNumber() + SequenceNumber(1);
+      m_nextTxSequence = tcpHeader.GetAckNumber ();
+      m_firstPendingSequence = m_nextTxSequence;  //bug 166
+      NS_LOG_DEBUG ("Tcp6SocketImpl " << this << " ACK_TX_1" <<
+                    " nextRxSeq " << m_nextRxSequence);
+      SendEmptyPacket (TcpHeader::ACK);
+      m_rxWindowSize = tcpHeader.GetWindowSize ();
+      if (tcpHeader.GetAckNumber () > m_highestRxAck)
+      {
+        m_highestRxAck = tcpHeader.GetAckNumber ();
+        // Data freed from the send buffer; notify any blocked sender
+        if (m_wouldBlock)
+          {
+            m_wouldBlock = false;
+            NotifySend (GetTxAvailable ());
+          }
+      }
+      SendPendingData ();
+      break;
+    case NEW_ACK:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action NEW_ACK_TX");
+      if (tcpHeader.GetAckNumber () < m_highestRxAck) //old ack, do nothing
+      {
+        break;
+      }
+      if (tcpHeader.GetAckNumber () == m_highestRxAck && 
+         tcpHeader.GetAckNumber ()  < m_nextTxSequence)
+      {
+        DupAck (tcpHeader, ++m_dupAckCount);
+        break;
+      }
+      if (tcpHeader.GetAckNumber () > m_highestRxAck)  
+        {
+          m_dupAckCount = 0;
+        }
+      NewAck (tcpHeader.GetAckNumber ());
+      break;
+    case NEW_SEQ_RX:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action NEW_SEQ_RX");
+      NewRx (p, tcpHeader, fromAddress); // Process new data received
+      break;
+    case PEER_CLOSE:
+    {
+      // First we have to be sure the FIN packet was not received
+      // out of sequence.  If so, note pending close and process
+      // new sequence rx
+      if (tcpHeader.GetSequenceNumber () != m_nextRxSequence)
+        { // process close later
+          m_pendingClose = true;
+          NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " setting pendingClose" 
+            << " rxseq " << tcpHeader.GetSequenceNumber () 
+            << " nextRxSeq " << m_nextRxSequence);
+          NewRx (p, tcpHeader, fromAddress);
+          return true;
+        }
+      // Now we need to see if any data came with the FIN
+      // if so, call NewRx
+      if (p->GetSize () != 0)
+        {
+          NewRx (p, tcpHeader, fromAddress);
+        }
+      States_t saveState = m_state; // Used to see if app responds
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this 
+          << " peer close, state " << m_state);
+      if (!m_closeRequestNotified)
+        {
+          NS_LOG_LOGIC ("TCP " << this 
+              << " calling AppCloseRequest");
+          m_closeRequestNotified = true;
+        }
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this 
+          << " peer close, state after " << m_state);
+      if (m_state == saveState)
+        { // Need to ack, the application will close later
+          SendEmptyPacket (TcpHeader::ACK);
+//               // Also need to re-tx the ack if we
+        }
+      if (m_state == LAST_ACK)
+        {
+          NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " scheduling LATO1");
+          m_lastAckEvent = Simulator::Schedule (m_rtt->RetransmitTimeout (),
+                                                &Tcp6SocketImpl::LastAckTimeout,this);
+        }
+      break;
+    }
+    case SERV_NOTIFY:
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this <<" Action SERV_NOTIFY");
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " Connected!");
+      NotifyNewConnectionCreated (this, fromAddress);
+      m_connected = true; // ! This is bogus; fix when we clone the tcp
+      m_endPoint->SetPeer (m_remoteAddress, m_remotePort);
+      //treat the connection orientation final ack as a newack
+      CommonNewAck (tcpHeader.GetAckNumber (), true);
+      break;
+    default:
+      break;
+  }
+  return true;
+}
+
+void Tcp6SocketImpl::CompleteFork(Ptr<Packet> p, const TcpHeader& h, const Address& fromAddress)
+{
+  // Get port and address from peer (connecting host)
+  m_remotePort = Inet6SocketAddress::ConvertFrom (fromAddress).GetPort ();
+  m_remoteAddress = Inet6SocketAddress::ConvertFrom (fromAddress).GetIpv6 ();
+  m_endPoint = m_tcp->Allocate (m_localAddress,
+                                m_localPort,
+                                m_remoteAddress,
+                                m_remotePort);
+  //the cloned socket with be in listen state, so manually change state
+  m_state = SYN_RCVD;
+  //equivalent to FinishBind
+  m_endPoint->SetRxCallback (MakeCallback (&Tcp6SocketImpl::ForwardUp, Ptr<Tcp6SocketImpl>(this)));
+  m_endPoint->SetDestroyCallback (MakeCallback (&Tcp6SocketImpl::Destroy, Ptr<Tcp6SocketImpl>(this)));
+  ProcessPacketAction(SYN_ACK_TX, p, h, fromAddress);
+ }
+
+void Tcp6SocketImpl::ConnectionSucceeded()
+{ // We would preferred to have scheduled an event directly to
+  // NotifyConnectionSucceeded, but (sigh) these are protected
+  // and we can get the address of it :(
+  NotifyConnectionSucceeded();
+}
+
+bool Tcp6SocketImpl::SendPendingData (bool withAck)
+{
+  NS_LOG_FUNCTION (this << withAck);
+  NS_LOG_LOGIC ("ENTERING SendPendingData");
+  if (!m_pendingData)
+    {
+      return false; // No data exists
+    }
+  uint32_t nPacketsSent = 0;
+  while (m_pendingData->SizeFromSeq (m_firstPendingSequence, m_nextTxSequence))
+    {
+      uint32_t w = AvailableWindow ();// Get available window size
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " SendPendingData"
+           << " w " << w 
+           << " rxwin " << m_rxWindowSize
+           << " cWnd " << m_cWnd
+           << " segsize " << m_segmentSize
+           << " nextTxSeq " << m_nextTxSequence
+           << " highestRxAck " << m_highestRxAck 
+           << " pd->Size " << m_pendingData->Size ()
+           << " pd->SFS " << m_pendingData->SizeFromSeq (m_firstPendingSequence, m_nextTxSequence));
+
+      if (w < m_segmentSize && m_pendingData->Size () > w)
+        {
+          break; // No more
+        }
+      uint32_t s = std::min (w, m_segmentSize);  // Send no more than window
+      Ptr<Packet> p = m_pendingData->CopyFromSeq (s, m_firstPendingSequence, 
+        m_nextTxSequence);
+      NS_LOG_LOGIC("Tcp6SocketImpl " << this << " SendPendingData"
+                   << " txseq " << m_nextTxSequence
+                   << " s " << s 
+                   << " datasize " << p->GetSize() );
+      uint8_t flags = 0;
+      if (withAck)
+        {
+          flags |= TcpHeader::ACK;
+        }
+      uint32_t sz = p->GetSize (); // Size of packet
+      uint32_t remainingData = m_pendingData->SizeFromSeq(
+          m_firstPendingSequence,
+          m_nextTxSequence + SequenceNumber (sz));
+      if (m_closeOnEmpty && (remainingData == 0))
+        {
+          flags = TcpHeader::FIN;
+          m_state = FIN_WAIT_1;
+        }
+
+      TcpHeader header;
+      header.SetFlags (flags);
+      header.SetSequenceNumber (m_nextTxSequence);
+      header.SetAckNumber (m_nextRxSequence);
+      header.SetSourcePort (m_endPoint->GetLocalPort());
+      header.SetDestinationPort (m_remotePort);
+      if (m_shutdownSend)
+        {
+          m_errno = ERROR_SHUTDOWN;
+          return -1;
+        }
+
+      
+      if (m_retxEvent.IsExpired () ) //go ahead and schedule the retransmit
+        {
+            Time rto = m_rtt->RetransmitTimeout (); 
+            NS_LOG_LOGIC ("SendPendingData Schedule retransmission timeout at time " << 
+              Simulator::Now ().GetSeconds () << " to expire at time " <<
+              (Simulator::Now () + rto).GetSeconds () );
+          m_retxEvent = Simulator::Schedule (rto,&Tcp6SocketImpl::ReTxTimeout,this);
+        }
+      NS_LOG_LOGIC ("About to send a packet with flags: " << flags);
+      m_tcp->SendPacket (p, header,
+                         m_endPoint->GetLocalAddress (),
+                         m_remoteAddress);
+      m_rtt->SentSeq(m_nextTxSequence, sz);       // notify the RTT
+      // Notify the application
+      Simulator::ScheduleNow(&Tcp6SocketImpl::NotifyDataSent, this, p->GetSize ());
+      nPacketsSent++;                             // Count sent this loop
+      m_nextTxSequence += sz;                     // Advance next tx sequence
+      // Note the high water mark
+      m_highTxMark = std::max (m_nextTxSequence, m_highTxMark);
+    }
+    NS_LOG_LOGIC ("SendPendingData Sent "<<nPacketsSent<<" packets");
+  NS_LOG_LOGIC("RETURN SendPendingData");
+  return (nPacketsSent>0);
+}
+
+uint32_t  Tcp6SocketImpl::UnAckDataCount ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_nextTxSequence - m_highestRxAck;
+}
+
+uint32_t  Tcp6SocketImpl::BytesInFlight ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_highTxMark - m_highestRxAck;
+}
+
+uint32_t  Tcp6SocketImpl::Window ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  NS_LOG_LOGIC ("Tcp6SocketImpl::Window() "<<this);
+  return std::min (m_rxWindowSize, m_cWnd.Get());
+}
+
+uint32_t  Tcp6SocketImpl::AvailableWindow ()
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  uint32_t unack = UnAckDataCount (); // Number of outstanding bytes
+  uint32_t win = Window ();
+  if (win < unack) 
+    {
+      return 0;  // No space available
+    }
+  return (win - unack);       // Amount of window space available
+}
+
+void Tcp6SocketImpl::NewRx (Ptr<Packet> p,
+                        const TcpHeader& tcpHeader, 
+                        const Address& fromAddress)
+{
+  NS_LOG_FUNCTION (this << p << "tcpHeader " << fromAddress);
+  NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " NewRx,"
+                << " seq " << tcpHeader.GetSequenceNumber()
+                << " ack " << tcpHeader.GetAckNumber()
+                << " p.size is " << p->GetSize () );
+  NS_LOG_DEBUG ("Tcp6SocketImpl " << this <<
+                " NewRx," <<
+                " seq " << tcpHeader.GetSequenceNumber() <<
+                " ack " << tcpHeader.GetAckNumber() <<
+                " p.size is " << p->GetSize());
+  States_t origState = m_state;
+  uint32_t s = p->GetSize ();  // Size of associated data
+  if (s == 0)
+    {// Nothing to do if no associated data
+      return;
+    }
+  // Log sequence received if enabled
+  // NoteTimeSeq(LOG_SEQ_RX, h->sequenceNumber);
+  // Three possibilities
+  // 1) Received seq is expected, buffer this, update rxAvailable, and ack
+  // 2) Received seq is < expected, just re-ack previous
+  // 3) Received seq is > expected, just re-ack previous and buffer data
+  if (tcpHeader.GetSequenceNumber () == m_nextRxSequence)
+    { // If seq is expected seq
+      // 1) Update nextRxSeq
+      // 2) Buffer this packet so Recv can read it
+      // 3) Send the ack
+      m_nextRxSequence += s;           // Advance next expected sequence
+      //bytesReceived += s;       // Statistics
+      NS_LOG_LOGIC("Case 1, advanced nrxs to " << m_nextRxSequence );
+      SocketAddressTag tag;
+      tag.SetAddress (fromAddress);
+      p->AddByteTag (tag);
+      //buffer this, it'll be read by call to Recv
+      UnAckData_t::iterator i = 
+          m_bufferedData.find (tcpHeader.GetSequenceNumber () );
+      if (i != m_bufferedData.end () ) //we found it already in the buffer
+      {
+        i->second = 0; // relase reference to already buffered
+      }
+      // Save for later delivery
+      m_bufferedData[tcpHeader.GetSequenceNumber () ] = p;  
+      m_rxAvailable += p->GetSize ();
+      //putting this into the buffer might have filled in a sequence gap
+      //so we have to iterate through the list to find the largest contiguous
+      //sequenced chunk, and update m_rxAvailable appropriately
+      i = m_bufferedData.find (tcpHeader.GetSequenceNumber () );
+      UnAckData_t::iterator next = i;
+      next++;
+      while(next != m_bufferedData.end())
+        {
+          if(i->first + SequenceNumber(i->second->GetSize ()) == next->first)
+            {
+                //next packet is in sequence, count it
+                m_rxAvailable += next->second->GetSize();
+                m_nextRxSequence += next->second->GetSize();
+            }
+          else
+            {
+                break; //no more in this contiguous chunk
+            }
+          ++i;
+          ++next;
+        }
+      NotifyDataRecv ();
+      if (m_closeNotified)
+        {
+          NS_LOG_LOGIC ("Tcp " << this << " HuH?  Got data after closeNotif");
+        }
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " adv rxseq by " << s);
+      if (m_pendingClose || (origState > ESTABLISHED))
+        { // See if we can close now
+          if (m_bufferedData.empty())
+            {
+              ProcessPacketAction (PEER_CLOSE, p, tcpHeader, fromAddress);
+            }
+        }
+    }
+  else if (SequenceNumber (tcpHeader.GetSequenceNumber ()) >= m_nextRxSequence)
+    { // Need to buffer this one
+      NS_LOG_LOGIC ("Case 2, buffering " << tcpHeader.GetSequenceNumber () );
+      UnAckData_t::iterator i = 
+        m_bufferedData.find (tcpHeader.GetSequenceNumber () );
+      if (i != m_bufferedData.end () )
+        {
+          i->second = 0; // relase reference to already buffered
+        }
+      // Save for later delivery
+      SocketAddressTag tag;
+      tag.SetAddress (fromAddress);
+      p->AddByteTag (tag);
+      m_bufferedData[tcpHeader.GetSequenceNumber () ] = p;  
+    }
+  else
+    { // debug
+      NS_LOG_LOGIC("TCP " << this 
+               << " got seq " << tcpHeader.GetSequenceNumber ()
+               << " expected " << m_nextRxSequence
+               << "       flags " << tcpHeader.GetFlags ());
+    }
+  // Now send a new ack packet acknowledging all received and delivered data
+  if(++m_delAckCount >= m_delAckMaxCount)
+  {
+    m_delAckEvent.Cancel();
+    m_delAckCount = 0;
+    SendEmptyPacket (TcpHeader::ACK);
+  }
+  else
+  {
+    m_delAckEvent = Simulator::Schedule (m_delAckTimeout, &Tcp6SocketImpl::DelAckTimeout, this);
+  }
+}
+
+void Tcp6SocketImpl::DelAckTimeout ()
+{
+  m_delAckCount = 0;
+  SendEmptyPacket (TcpHeader::ACK);
+}
+
+void Tcp6SocketImpl::CommonNewAck (SequenceNumber ack, bool skipTimer)
+{ // CommonNewAck is called only for "New" (non-duplicate) acks
+  // and MUST be called by any subclass, from the NewAck function
+  // Always cancel any pending re-tx timer on new acknowledgement
+  NS_LOG_FUNCTION (this << ack << skipTimer); 
+  //DEBUG(1,(cout << "TCP " << this << "Cancelling retx timer " << endl));
+  if (!skipTimer)
+    {
+      m_retxEvent.Cancel ();  
+      //On recieving a "New" ack we restart retransmission timer .. RFC 2988
+      Time rto = m_rtt->RetransmitTimeout ();
+      NS_LOG_LOGIC ("Schedule retransmission timeout at time " 
+          << Simulator::Now ().GetSeconds () << " to expire at time " 
+          << (Simulator::Now () + rto).GetSeconds ());
+    m_retxEvent = Simulator::Schedule (rto, &Tcp6SocketImpl::ReTxTimeout, this);
+    }
+  NS_LOG_LOGIC ("TCP " << this << " NewAck " << ack 
+           << " numberAck " << (ack - m_highestRxAck)); // Number bytes ack'ed
+  m_highestRxAck = ack;         // Note the highest recieved Ack
+  if (m_wouldBlock)
+    {
+      // m_highestRxAck advancing means some data was acked, and the size 
+      // of free space in the buffer has increased
+      m_wouldBlock = false;
+      NotifySend (GetTxAvailable ());
+    }
+  if (ack > m_nextTxSequence) 
+    {
+      m_nextTxSequence = ack; // If advanced
+    }
+  // See if all pending ack'ed; if so we can delete the data
+  if (m_pendingData)
+    { // Data exists, see if can be deleted
+      if (m_pendingData->SizeFromSeq (m_firstPendingSequence, m_highestRxAck) == 0)
+        { // All pending acked, can be deleted
+          m_pendingData->Clear ();
+          delete m_pendingData;
+          m_pendingData = 0;
+          // Insure no re-tx timer
+          m_retxEvent.Cancel ();
+        }
+    }
+  // Try to send more data
+  SendPendingData();
+}
+
+Ptr<Tcp6SocketImpl> Tcp6SocketImpl::Copy ()
+{
+  return CopyObject<Tcp6SocketImpl> (this);
+}
+
+void Tcp6SocketImpl::NewAck (SequenceNumber seq)
+{ // New acknowledgement up to sequence number "seq"
+  // Adjust congestion window in response to new ack's received
+  NS_LOG_FUNCTION (this << seq);
+  NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " NewAck "
+           << " seq " << seq
+           << " cWnd " << m_cWnd
+           << " ssThresh " << m_ssThresh);
+  if (m_cWnd < m_ssThresh)
+    { // Slow start mode, add one segSize to cWnd
+      m_cWnd += m_segmentSize;
+      NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " NewCWnd SlowStart, cWnd " << m_cWnd 
+          << " sst " << m_ssThresh);
+    }
+  else
+    { // Congestion avoidance mode, adjust by (ackBytes*segSize) / cWnd
+      double adder =  ((double) m_segmentSize * m_segmentSize) / m_cWnd.Get();
+      if (adder < 1.0) 
+        {
+          adder = 1.0;
+        }
+      m_cWnd += (uint32_t) adder;
+      NS_LOG_LOGIC ("NewCWnd CongAvoid, cWnd " << m_cWnd 
+           << " sst " << m_ssThresh);
+    }
+  CommonNewAck (seq, false);           // Complete newAck processing
+}
+
+void Tcp6SocketImpl::DupAck (const TcpHeader& t, uint32_t count)
+{
+  NS_LOG_FUNCTION (this << "t " << count);
+  NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " DupAck " <<  t.GetAckNumber ()
+      << ", count " << count
+      << ", time " << Simulator::Now ());
+  if (count == 3)
+  { // Count of three indicates triple duplicate ack
+    m_ssThresh = Window () / 2; // Per RFC2581
+    m_ssThresh = std::max (m_ssThresh, 2 * m_segmentSize);
+    NS_LOG_LOGIC("Tcp6SocketImpl " << this << "Tahoe TDA, time " << Simulator::Now ()
+        << " seq " << t.GetAckNumber ()
+        << " in flight " << BytesInFlight ()
+        << " new ssthresh " << m_ssThresh);
+
+    m_cWnd = m_segmentSize; // Collapse cwnd (re-enter slowstart)
+    // For Tahoe, we also reset nextTxSeq
+    m_nextTxSequence = m_highestRxAck;
+    SendPendingData ();
+  }
+}
+
+void Tcp6SocketImpl::ReTxTimeout ()
+{ // Retransmit timeout
+  NS_LOG_FUNCTION (this);
+  m_ssThresh = Window () / 2; // Per RFC2581
+  m_ssThresh = std::max (m_ssThresh, 2 * m_segmentSize);
+  // Set cWnd to segSize on timeout,  per rfc2581
+  // Collapse congestion window (re-enter slowstart)
+  m_cWnd = m_segmentSize;           
+  m_nextTxSequence = m_highestRxAck; // Start from highest Ack
+  m_rtt->IncreaseMultiplier (); // DoubleValue timeout value for next retx timer
+  Retransmit ();             // Retransmit the packet
+}
+
+void Tcp6SocketImpl::LastAckTimeout ()
+{
+  m_lastAckEvent.Cancel ();
+  if (m_state == LAST_ACK)
+    {
+      Actions_t action = ProcessEvent (TIMEOUT);
+      ProcessAction (action);
+    }
+  if (!m_closeNotified)
+    {
+      m_closeNotified = true;
+    }
+}
+
+void Tcp6SocketImpl::Retransmit ()
+{
+  NS_LOG_FUNCTION (this);
+  uint8_t flags = TcpHeader::NONE;
+  if (m_state == SYN_SENT) 
+    {
+      if (m_cnCount > 0) 
+        {
+          SendEmptyPacket (TcpHeader::SYN);
+          return;
+        }
+      else
+        {
+          NotifyConnectionFailed ();
+          return;
+        }
+    } 
+  if (!m_pendingData)
+    {
+      if (m_state == FIN_WAIT_1)
+        { // Must have lost FIN, re-send
+          SendEmptyPacket (TcpHeader::FIN);
+        }
+      return;
+    }
+  Ptr<Packet> p = m_pendingData->CopyFromSeq (m_segmentSize,
+                                            m_firstPendingSequence,
+                                            m_highestRxAck);
+  // Calculate remaining data for COE check
+  uint32_t remainingData = m_pendingData->SizeFromSeq (
+      m_firstPendingSequence,
+      m_nextTxSequence + SequenceNumber(p->GetSize ()));
+  if (m_closeOnEmpty && remainingData == 0)
+    { // Add the FIN flag
+      flags = flags | TcpHeader::FIN;
+    }
+
+  NS_LOG_LOGIC ("Tcp6SocketImpl " << this << " retxing seq " << m_highestRxAck);
+  if (m_retxEvent.IsExpired () )
+    {
+      Time rto = m_rtt->RetransmitTimeout ();
+      NS_LOG_LOGIC ("Schedule retransmission timeout at time "
+          << Simulator::Now ().GetSeconds () << " to expire at time "
+          << (Simulator::Now () + rto).GetSeconds ());
+      m_retxEvent = Simulator::Schedule (rto,&Tcp6SocketImpl::ReTxTimeout,this);
+    }
+  m_rtt->SentSeq (m_highestRxAck,p->GetSize ());
+  // And send the packet
+  TcpHeader tcpHeader;
+  tcpHeader.SetSequenceNumber (m_nextTxSequence);
+  tcpHeader.SetAckNumber (m_nextRxSequence);
+  tcpHeader.SetSourcePort (m_endPoint->GetLocalPort());
+  tcpHeader.SetDestinationPort (m_remotePort);
+  tcpHeader.SetFlags (flags);
+  tcpHeader.SetWindowSize (m_advertisedWindowSize);
+
+  m_tcp->SendPacket (p, tcpHeader, m_endPoint->GetLocalAddress (),
+    m_remoteAddress);
+}
+
+void
+Tcp6SocketImpl::SetSndBufSize (uint32_t size)
+{
+  m_sndBufSize = size;
+}
+
+uint32_t
+Tcp6SocketImpl::GetSndBufSize (void) const
+{
+  return m_sndBufSize;
+}
+
+void
+Tcp6SocketImpl::SetRcvBufSize (uint32_t size)
+{
+  m_rcvBufSize = size;
+}
+
+uint32_t
+Tcp6SocketImpl::GetRcvBufSize (void) const
+{
+  return m_rcvBufSize;
+}
+
+void
+Tcp6SocketImpl::SetSegSize (uint32_t size)
+{
+  m_segmentSize = size;
+}
+
+uint32_t
+Tcp6SocketImpl::GetSegSize (void) const
+{
+  return m_segmentSize;
+}
+
+void
+Tcp6SocketImpl::SetAdvWin (uint32_t window)
+{
+  m_advertisedWindowSize = window;
+}
+
+uint32_t
+Tcp6SocketImpl::GetAdvWin (void) const
+{
+  return m_advertisedWindowSize;
+}
+
+void
+Tcp6SocketImpl::SetSSThresh (uint32_t threshold)
+{
+  m_ssThresh = threshold;
+}
+
+uint32_t
+Tcp6SocketImpl::GetSSThresh (void) const
+{
+  return m_ssThresh;
+}
+
+void
+Tcp6SocketImpl::SetInitialCwnd (uint32_t cwnd)
+{
+  m_initialCWnd = cwnd;
+}
+
+uint32_t
+Tcp6SocketImpl::GetInitialCwnd (void) const
+{
+  return m_initialCWnd;
+}
+
+void 
+Tcp6SocketImpl::SetConnTimeout (Time timeout)
+{
+  m_cnTimeout = timeout;
+}
+
+Time
+Tcp6SocketImpl::GetConnTimeout (void) const
+{
+  return m_cnTimeout;
+}
+
+void 
+Tcp6SocketImpl::SetConnCount (uint32_t count)
+{
+  m_cnCount = count;
+}
+
+uint32_t 
+Tcp6SocketImpl::GetConnCount (void) const
+{
+  return m_cnCount;
+}
+
+void 
+Tcp6SocketImpl::SetDelAckTimeout (Time timeout)
+{
+  m_delAckTimeout = timeout;
+}
+
+Time
+Tcp6SocketImpl::GetDelAckTimeout (void) const
+{
+  return m_delAckTimeout;
+}
+
+void
+Tcp6SocketImpl::SetDelAckMaxCount (uint32_t count)
+{
+  m_delAckMaxCount = count;
+}
+
+uint32_t
+Tcp6SocketImpl::GetDelAckMaxCount (void) const
+{
+  return m_delAckMaxCount;
+}
+
+int
+Tcp6SocketImpl::GetSockName (Address &address) const
+{
+  NS_ASSERT (0);
+  return 0;
+}
+
+}//namespace ns3
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/internet-stack/tcp6-socket-impl.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,218 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007 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: Raj Bhattacharjea <raj.b@gatech.edu>
+ * 				 Sebastien Vincent <vincent@clarinet.u-strasbg.fr>
+ */
+
+#ifndef TCP6_SOCKET_IMPL_H
+#define TCP6_SOCKET_IMPL_H
+
+#include <stdint.h>
+#include <queue>
+#include "ns3/callback.h"
+#include "ns3/traced-value.h"
+#include "ns3/tcp-socket.h"
+#include "ns3/ptr.h"
+#include "ns3/ipv6-address.h"
+#include "ns3/event-id.h"
+#include "tcp-typedefs.h"
+#include "pending-data.h"
+#include "sequence-number.h"
+#include "rtt-estimator.h"
+
+
+namespace ns3 {
+
+class Ipv6EndPoint;
+class Node;
+class Packet;
+class Tcp6L4Protocol;
+class TcpHeader;
+
+class Tcp6SocketImpl : public TcpSocket
+{
+public:
+  static TypeId GetTypeId (void);
+  /**
+   * Create an unbound tcp socket.
+   */
+  Tcp6SocketImpl ();
+  Tcp6SocketImpl (const Tcp6SocketImpl& sock);
+  virtual ~Tcp6SocketImpl ();
+
+  void SetNode (Ptr<Node> node);
+  void SetTcp (Ptr<Tcp6L4Protocol> tcp);
+  void SetRtt (Ptr<RttEstimator> rtt);
+
+  virtual enum SocketErrno GetErrno (void) const;
+  virtual Ptr<Node> GetNode (void) const;
+  virtual int Bind (void);
+  virtual int Bind (const Address &address);
+  virtual int Close (void);
+  virtual int ShutdownSend (void);
+  virtual int ShutdownRecv (void);
+  virtual int Connect(const Address &address);
+  virtual uint32_t GetTxAvailable (void) const;
+  virtual int Listen(void);
+  virtual int Send (Ptr<Packet> p, uint32_t flags);
+  virtual int SendTo(Ptr<Packet> p, uint32_t flags, const Address &toAddress);
+  virtual uint32_t GetRxAvailable (void) const;
+  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);
+  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress);
+  virtual int GetSockName (Address &address) const;
+
+
+private:
+  friend class Tcp;
+  // invoked by Tcp class
+  int FinishBind (void);
+  void ForwardUp (Ptr<Packet> p, Ipv6Address ipv6, uint16_t port);
+  void Destroy (void);
+  int DoSendTo (Ptr<Packet> p, const Address &daddr);
+  int DoSendTo (Ptr<Packet> p, Ipv6Address daddr, uint16_t dport);
+  void SendEmptyPacket(uint8_t flags);
+  //methods for state
+  bool ProcessAction (Actions_t a);
+  bool ProcessAction (Actions_t a, const TcpHeader& tcpHeader,
+                      Ipv6Address saddr, Ipv6Address daddr);
+  bool ProcessPacketAction (Actions_t a, Ptr<Packet> p,
+                                       const TcpHeader& tcpHeader,
+                                       const Address& fromAddress);
+  Actions_t ProcessEvent (Events_t e);
+  bool SendPendingData(bool withAck = false);
+  void CompleteFork(Ptr<Packet>, const TcpHeader&, const Address& fromAddress);
+  void ConnectionSucceeded();
+  
+  //methods for window management
+  virtual uint32_t  UnAckDataCount(); // Return count of number of unacked bytes
+  virtual uint32_t  BytesInFlight();  // Return total bytes in flight
+  virtual uint32_t  Window();         // Return window size (integer)
+  virtual uint32_t  AvailableWindow();// Return unfilled portion of window
+
+  // Manage data tx/rx
+  void NewRx (Ptr<Packet>, const TcpHeader&, const Address&);
+  // XXX This should be virtual and overridden
+  Ptr<Tcp6SocketImpl> Copy ();
+  void NewAck (SequenceNumber seq); 
+  // XXX This should be virtual and overridden
+  void DupAck (const TcpHeader& t, uint32_t count); 
+  void ReTxTimeout ();
+  void DelAckTimeout ();
+  void LastAckTimeout ();
+  void Retransmit ();
+  void CommonNewAck (SequenceNumber seq, bool skipTimer = false);
+
+  // attribute related
+  virtual void SetSndBufSize (uint32_t size);
+  virtual uint32_t GetSndBufSize (void) const;
+  virtual void SetRcvBufSize (uint32_t size);
+  virtual uint32_t GetRcvBufSize (void) const;
+  virtual void SetSegSize (uint32_t size);
+  virtual uint32_t GetSegSize (void) const;
+  virtual void SetAdvWin (uint32_t window);
+  virtual uint32_t GetAdvWin (void) const;
+  virtual void SetSSThresh (uint32_t threshold);
+  virtual uint32_t GetSSThresh (void) const;
+  virtual void SetInitialCwnd (uint32_t cwnd);
+  virtual uint32_t GetInitialCwnd (void) const;
+  virtual void SetConnTimeout (Time timeout);
+  virtual Time GetConnTimeout (void) const;
+  virtual void SetConnCount (uint32_t count);
+  virtual uint32_t GetConnCount (void) const;
+  virtual void SetDelAckTimeout (Time timeout);
+  virtual Time GetDelAckTimeout (void) const;
+  virtual void SetDelAckMaxCount (uint32_t count);
+  virtual uint32_t GetDelAckMaxCount (void) const;
+
+  bool m_skipRetxResched;
+  uint32_t m_dupAckCount;
+  EventId m_retxEvent;
+  EventId m_lastAckEvent;
+
+  EventId m_delAckEvent;
+  uint32_t m_delAckCount;
+  uint32_t m_delAckMaxCount;
+  Time m_delAckTimeout;
+
+  Ipv6EndPoint *m_endPoint;
+  Ptr<Node> m_node;
+  Ptr<Tcp6L4Protocol> m_tcp;
+  Ipv6Address m_remoteAddress;
+  uint16_t m_remotePort;
+  //these two are so that the socket/endpoint cloning works
+  Ipv6Address m_localAddress;
+  uint16_t m_localPort;
+  enum SocketErrno m_errno;
+  bool m_shutdownSend;
+  bool m_shutdownRecv;
+  bool m_connected;
+  
+  //manage the state infomation
+  States_t m_state;
+  bool m_closeNotified;
+  bool m_closeRequestNotified;
+  bool m_closeOnEmpty;
+  bool m_pendingClose;
+
+  
+  //sequence info, sender side
+  SequenceNumber m_nextTxSequence;
+  SequenceNumber m_highTxMark;
+  SequenceNumber m_highestRxAck;
+  SequenceNumber m_lastRxAck;
+  
+  //sequence info, reciever side
+  SequenceNumber m_nextRxSequence;
+
+  //history data
+  //this is the incoming data buffer which sorts out of sequence data
+  UnAckData_t m_bufferedData;
+  //this is kind of the tx buffer
+  PendingData* m_pendingData;
+  SequenceNumber m_firstPendingSequence;
+
+  // Window management
+  uint32_t                       m_segmentSize;          //SegmentSize
+  uint32_t                       m_rxWindowSize;
+  uint32_t                       m_advertisedWindowSize; //Window to advertise
+  TracedValue<uint32_t>          m_cWnd;                 //Congestion window
+  uint32_t                       m_ssThresh;             //Slow Start Threshold
+  uint32_t                       m_initialCWnd;          //Initial cWnd value
+
+  // Round trip time estimation
+  Ptr<RttEstimator> m_rtt;
+  Time m_lastMeasuredRtt;
+
+  // Timer-related members
+  Time              m_cnTimeout; 
+  uint32_t          m_cnCount;
+
+  // Temporary queue for delivering data to application
+  uint32_t m_rxAvailable;
+
+  bool m_wouldBlock;  // set to true whenever socket would block on send()
+
+  // Attributes
+  uint32_t m_sndBufSize;   // buffer limit for the outgoing queue
+  uint32_t m_rcvBufSize;   // maximum receive socket buffer size
+};
+
+}//namespace ns3
+
+#endif /* TCP6_SOCKET_IMPL_H */
+
--- a/src/internet-stack/wscript	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/internet-stack/wscript	Thu Oct 01 23:37:18 2009 +0900
@@ -110,7 +110,10 @@
-        'ipv6-test.cc'
+        'ipv6-test.cc',
+        'tcp6-socket-factory-impl.cc',
+        'tcp6-l4-protocol.cc',
+        'tcp6-socket-impl.cc',
@@ -128,6 +131,10 @@
+        'ipv6-raw-socket-impl.h',
+        'ipv6-interface.h',
+        'ipv6-l3-protocol.h',
+        'ndisc-cache.h',
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/mobility/oneway-mobility-model.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,120 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 WIDE Project
+ *
+ * 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: Hajime Tazaki <tazaki@sfc.wide.ad.jp>
+ */
+#include "ns3/simulator.h"
+#include "ns3/random-variable.h"
+#include "ns3/pointer.h"
+#include "oneway-mobility-model.h"
+#include "position-allocator.h"
+
+namespace ns3 {
+
+NS_OBJECT_ENSURE_REGISTERED (OnewayMobilityModel);
+
+TypeId
+OnewayMobilityModel::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::OnewayMobilityModel")
+    .SetParent<MobilityModel> ()
+    .SetGroupName ("Mobility")
+    .AddConstructor<OnewayMobilityModel> ()
+    .AddAttribute ("Speed",
+                   "A random variable used to pick the speed of a random waypoint model.",
+                   RandomVariableValue (UniformVariable (0.3, 0.7)),
+                   MakeRandomVariableAccessor (&OnewayMobilityModel::m_speed),
+                   MakeRandomVariableChecker ())
+    .AddAttribute ("Pause",
+                   "A random variable used to pick the pause of a random waypoint model.",
+                   RandomVariableValue (ConstantVariable (2.0)),
+                   MakeRandomVariableAccessor (&OnewayMobilityModel::m_pause),
+                   MakeRandomVariableChecker ())
+    .AddAttribute ("Wait",
+                   "A wait duration before moving.",
+                   RandomVariableValue (ConstantVariable (10.0)),
+                   MakeRandomVariableAccessor (&OnewayMobilityModel::m_wait),
+                   MakeRandomVariableChecker ())
+    .AddAttribute ("Destination",
+                   "Destination.",
+                   VectorValue (Vector (0.0, 100.0, 0.0)),
+                   MakeVectorAccessor (&OnewayMobilityModel::m_destination),
+                   MakeVectorChecker ())
+                   ;
+  
+  return tid;
+}
+
+OnewayMobilityModel::OnewayMobilityModel ()
+{
+  Simulator::ScheduleNow (&OnewayMobilityModel::Start, this);
+}
+
+void
+OnewayMobilityModel::BeginWalk (void)
+{
+  m_helper.Update ();
+  Vector m_current = m_helper.GetCurrentPosition ();
+  double dx = (m_destination.x - m_current.x);
+  double dy = (m_destination.y - m_current.y);
+  double dz = (m_destination.z - m_current.z);
+  m_helper.SetVelocity (Vector (0.5*dx, 0.5*dy, 0.5*dz));
+  m_helper.Unpause ();
+  //  Time travelDelay = Seconds (CalculateDistance (m_destination, m_current) / speed);
+  Time travelDelay = Seconds (1.0);
+  m_pause = ConstantVariable(1.0);
+  m_event = Simulator::Schedule (travelDelay,
+				 &OnewayMobilityModel::Start, this);
+  NotifyCourseChange ();
+}
+
+void
+OnewayMobilityModel::Start (void)
+{
+  static int cnt = 0;
+  if (cnt++ == 0)
+    {
+      m_pause = m_wait;
+    }
+  m_helper.Update ();
+  m_helper.Pause ();
+  Time pause = Seconds (m_pause.GetValue ());
+  m_event = Simulator::Schedule (pause, &OnewayMobilityModel::BeginWalk, this);
+  NotifyCourseChange ();
+}
+
+Vector
+OnewayMobilityModel::DoGetPosition (void) const
+{
+  m_helper.Update ();
+  return m_helper.GetCurrentPosition ();
+}
+void 
+OnewayMobilityModel::DoSetPosition (const Vector &position)
+{
+  m_helper.SetPosition (position);
+  Simulator::Remove (m_event);
+  Simulator::ScheduleNow (&OnewayMobilityModel::Start, this);
+}
+Vector
+OnewayMobilityModel::DoGetVelocity (void) const
+{
+  return m_helper.GetVelocity ();
+}
+
+
+} // namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/mobility/oneway-mobility-model.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,68 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 WIDE Project
+ *
+ * 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: Hajime Tazaki <tazaki@sfc.wide.ad.jp>
+ */
+#ifndef ONEWAY_MOBILITY_MODEL_H
+#define ONEWAY_MOBILITY_MODEL_H
+
+#include "constant-velocity-helper.h"
+#include "ns3/event-id.h"
+#include "mobility-model.h"
+#include "position-allocator.h"
+#include "ns3/ptr.h"
+#include "ns3/random-variable.h"
+
+namespace ns3 {
+
+/**
+ * \brief a random waypoint mobility model
+ *
+ * Each object chooses a random destination "waypoint", a random speed,
+ * and a random pause time: it then pauses for the specified pause time,
+ * and starts moving towards the specified destination with the specified
+ * speed. Once the destination is reached the process starts again.
+ *
+ * The implementation of this model is not 2d-specific. i.e. if you provide
+ * a 3d random waypoint position model to this mobility model, the model 
+ * will still work. There is no 3d position allocator for now but it should
+ * be trivial to add one.
+ */
+class OnewayMobilityModel : public MobilityModel
+{
+public:
+  static TypeId GetTypeId (void);
+  OnewayMobilityModel ();
+private:
+  void Start (void);
+  void BeginWalk (void);
+  virtual Vector DoGetPosition (void) const;
+  virtual void DoSetPosition (const Vector &position);
+  virtual Vector DoGetVelocity (void) const;
+
+  ConstantVelocityHelper m_helper;
+  Ptr<PositionAllocator> m_position;
+  Vector m_destination;
+  RandomVariable m_speed;
+  RandomVariable m_pause;
+  RandomVariable m_wait;
+  EventId m_event;
+};
+
+} // namespace ns3
+
+#endif /* ONEWAY_MOBILITY_MODEL_H */
--- a/src/mobility/wscript	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/mobility/wscript	Thu Oct 01 23:37:18 2009 +0900
@@ -14,6 +14,7 @@
+        'oneway-mobility-model.cc',
@@ -30,4 +31,5 @@
+        'oneway-mobility-model.h',
--- a/src/node/ipv6-address.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/node/ipv6-address.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -680,6 +680,33 @@
+uint8_t
+Ipv6Prefix::PrefixLen (void)
+{
+
+  uint8_t *pnt;
+  uint8_t val;
+  uint8_t len = 0;
+  pnt = (uint8_t *) & m_prefix;
+
+  while ((*pnt == 0xff) && len < 128) 
+    {
+      len += 8;
+      pnt++;
+    } 
+  
+  if (len < 128) 
+    {
+      val = *pnt;
+      while (val) 
+        {
+          len++;
+          val <<= 1;
+        }
+    }
+  return len;
+}
+
--- a/src/node/ipv6-address.h	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/node/ipv6-address.h	Thu Oct 01 23:37:18 2009 +0900
@@ -373,6 +373,8 @@
+    uint8_t PrefixLen (void);
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-attribute.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,447 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#include "ns3/netlink-attribute.h"
+#include "ns3/netlink-message.h"
+#include "ns3/netlink-message-route.h"
+#include "ns3/address-utils.h"
+
+namespace ns3 {
+
+
+/***********************************************************************************
+* \ NetlinkAttributeValue
+***********************************************************************************/
+NetlinkAttributeValue::NetlinkAttributeValue ()
+{
+  m_type = UNSPEC;
+  m_u32 = 0;
+}
+
+NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint8_t v)
+{
+  NS_ASSERT(type == U8);
+  m_type = U8;
+  m_u8 = v;
+}
+NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint16_t v)
+{
+  NS_ASSERT(type == U16);
+  m_type = U16;
+  m_u16 = v;
+}
+NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint32_t v)
+{
+  NS_ASSERT(type == U32);
+  m_type = U32;
+  m_u32 = v;
+}
+NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, uint64_t v)
+{
+  NS_ASSERT(type == U64);
+  m_type = U64;
+  m_u64 = v;
+}
+NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, std::string v)
+{
+  NS_ASSERT(type == STRING);
+  m_type = STRING;
+  m_string = v;
+}
+NetlinkAttributeValue:: NetlinkAttributeValue (NetlinkAttributeValueType type, Address v)
+{
+  NS_ASSERT(type == ADDRESS);
+  m_type = ADDRESS;
+  m_address = v;
+}
+
+void
+NetlinkAttributeValue::SetType (NetlinkAttributeValueType type)
+{
+  m_type = type;
+}
+NetlinkAttributeValueType
+NetlinkAttributeValue::GetType (void) const
+{
+  return m_type;
+}
+void
+NetlinkAttributeValue::SetAddress (Address value)
+{
+  m_address = value;
+}
+void
+NetlinkAttributeValue::SetString (std::string value)
+{
+  m_string = value;
+}
+void
+NetlinkAttributeValue::SetU64 (uint64_t value)
+{
+  m_u64 = value;
+}
+void
+NetlinkAttributeValue::SetU32 (uint32_t value)
+{
+  m_u32 = value;
+}
+void
+NetlinkAttributeValue::SetU16 (uint16_t value)
+{
+  m_u16 = value;
+}
+void
+NetlinkAttributeValue::SetU8 (uint8_t value)
+{
+  m_u8 = value;
+}
+Address
+NetlinkAttributeValue::GetAddress (void) const
+{
+  return m_address;
+}
+std::string
+NetlinkAttributeValue::GetString (void) const
+{
+  return m_string;
+}
+uint64_t
+NetlinkAttributeValue::GetU64 (void) const
+{
+  return m_u64;
+}
+uint32_t
+NetlinkAttributeValue::GetU32 (void) const
+{
+  return m_u32;
+}
+uint16_t
+NetlinkAttributeValue::GetU16 (void) const
+{
+  return m_u16;
+}
+uint8_t
+NetlinkAttributeValue::GetU8 (void) const
+{
+  return m_u8;
+}
+
+void
+NetlinkAttributeValue::Serialize (Buffer::Iterator& start) const
+{
+  uint32_t len;
+
+  if (m_type == U8)
+    {
+      start.WriteU8 (m_u8);
+      len = 1;
+    }
+  else if(m_type == U16)
+    {
+      start.WriteU16 (m_u16);
+      len = 2;
+    }
+  else if(m_type == U32)
+    {
+      start.WriteU32 (m_u32);
+      len = 4;
+    }
+  else if(m_type == STRING)
+    {
+      start.Write ((const uint8_t *)m_string.c_str (), (uint32_t)m_string.size ()+1);
+      len = (uint32_t)m_string.size () + 1;
+    }
+  else if(m_type == ADDRESS)
+    {
+      WriteTo(start, m_address);
+      len = m_address.GetLength ();
+    }
+  else
+    {
+      len = 0;
+    }
+  //netlink align
+  start.WriteU8 (0, NETLINK_MSG_ALIGN(len) - len);
+}
+
+uint32_t
+NetlinkAttributeValue::DeserializeWithType (Buffer::Iterator& start, NetlinkAttributeValueType_e type, uint16_t remaining)
+{
+  uint32_t len =0;
+  m_type = type;  
+
+  if (m_type == U8)
+    {
+      m_u8 = start.ReadU8 ();
+      len = 1;
+    }
+  else if(m_type == U16)
+    {
+      m_u16 = start.ReadU16 ();
+      len = 2;
+    }
+  else if(m_type == U32)
+    {
+      m_u32 = start.ReadU32 ();
+      len = 4;
+    }
+  else if (m_type == U64)
+    {
+      m_u64 = start.ReadU64 ();
+    }  
+  else if(m_type == STRING)
+    {
+      char buf[512];
+      uint32_t i = 0;
+      do 
+      {
+        buf[i] = start.ReadU8 ();
+      } while (buf[i++]);
+      
+      m_string = std::string(buf);
+      len = (uint32_t)m_string.size () + 1;
+    }
+  else if(m_type == ADDRESS)
+    {
+      ReadFrom(start, m_address, remaining);
+      len = m_address.GetLength ();
+    }
+  else
+    {
+      len = 0;
+    }
+
+  //netlink align
+  uint8_t buf[4];
+  start.Read(buf, NETLINK_MSG_ALIGN(len) - len);
+  
+  return NETLINK_MSG_ALIGN(len);
+}
+
+uint32_t
+NetlinkAttributeValue::GetSerializedSize ()const
+{
+  return NETLINK_MSG_ALIGN(GetSize ());
+}
+
+uint32_t
+NetlinkAttributeValue::GetSize () const
+{
+  uint32_t len;
+
+  if (m_type == U8)
+    {
+      len = 1;
+    }
+  else if(m_type == U16)
+    {
+      len =  2;
+    }
+  else if(m_type == U32)
+    {
+      len =  4;
+    }
+  else if (m_type == STRING)
+    {
+      len =  uint32_t(m_string.size () + 1);
+    }
+  else if (m_type == ADDRESS)
+    {
+      len =  m_address.GetLength ();
+    }
+  else
+    {
+      len = 0;
+    }
+
+    return len;
+}
+
+void
+NetlinkAttributeValue::Print(std::ostream &os) const
+{
+  os << "NetlinkAttributeValue (type= " << m_type <<", v= ";
+  if (m_type == U8)
+    {
+      os << m_u8;
+    }
+  else if(m_type == U16)
+    {
+      os << m_u16;
+    }
+  else if(m_type == U32)
+    {
+      os << m_u32;
+    }
+  else if (m_type == U64)
+    {
+      os << m_u64;
+    }  
+  else if (m_type == STRING)
+    {
+      os << m_string;
+    }
+  else if (m_type == ADDRESS)
+    {
+      os << "address(" << m_address <<")";
+    }
+  else
+    {
+      os << "NULL";
+    }
+  os <<")";
+}
+
+
+/***********************************************************************************
+* \ NetlinkAttribute
+***********************************************************************************/
+
+NetlinkAttribute::NetlinkAttribute ()
+: m_len(4),
+  m_type (0)
+{
+}
+
+NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint8_t payload)
+{
+  m_payload = NetlinkAttributeValue (payloadtype, payload);
+  m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();
+  m_type = type;
+}
+
+NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint16_t payload)
+{
+  m_payload = NetlinkAttributeValue (payloadtype, payload);
+  m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();
+  m_type = type;
+}
+NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint32_t payload)
+{
+  m_payload = NetlinkAttributeValue (payloadtype, payload);
+  m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();
+  m_type = type;;
+}
+NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint64_t payload)
+{
+  m_payload = NetlinkAttributeValue (payloadtype, payload);
+  m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();
+  m_type = type;
+}
+NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  std::string payload)
+{
+  m_payload = NetlinkAttributeValue (payloadtype, payload);
+  m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();
+  m_type = type;
+}
+NetlinkAttribute::NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  Address payload)
+{
+  m_payload = NetlinkAttributeValue (payloadtype, payload);
+  m_len = NETLINK_MSG_ATTR_SIZE + m_payload.GetSize ();
+  m_type = type;
+}
+
+void
+NetlinkAttribute::SetAttrLen(uint16_t v)
+{
+  m_len = v;
+}
+void 
+NetlinkAttribute::SetAttrType (uint16_t v)
+{
+  m_type = v;
+}
+void
+NetlinkAttribute::SetAttrPayload(NetlinkAttributeValue v)
+{
+  m_payload = v;
+}
+uint16_t
+NetlinkAttribute::GetAttrLen() const
+{
+  return m_len;
+}
+uint16_t
+NetlinkAttribute::GetAttrType () const
+{
+  return m_type;
+}
+NetlinkAttributeValue
+NetlinkAttribute::GetAttrPayload() const
+{
+  return m_payload;
+}
+
+//TypeId 
+//NetlinkAttribute::GetTypeId (void)
+//{
+//  static TypeId tid = TypeId ("ns3::NetlinkAttribute")
+//    .SetParent<Header> ()
+//    .AddConstructor<NetlinkAttribute> ()
+//    ;
+//  return tid;
+//}
+//
+//TypeId 
+//NetlinkAttribute::GetInstanceTypeId (void) const
+//{
+//  return GetTypeId ();
+//}
+
+void 
+NetlinkAttribute::Print (std::ostream &os) const
+{  
+  os << "NetlinkAttribute "
+    << "len: " << m_len << " "
+    << "type: " << m_type<<" "
+    << "payload:[";
+  m_payload.Print(os);
+  os<<"]";
+}
+
+uint32_t 
+NetlinkAttribute::GetSerializedSize (void) const
+{
+  /* this is the size of an nlattr payload. */
+  return NETLINK_MSG_ATTR_SIZE + m_payload.GetSerializedSize ();
+}
+
+void
+NetlinkAttribute::Serialize (Buffer::Iterator& start) const
+{
+  start.WriteU16 (m_len);
+  start.WriteU16 (m_type);
+  m_payload.Serialize (start);
+}
+
+uint32_t
+NetlinkAttribute::Deserialize (Buffer::Iterator& start, NetlinkAttributeValueType vtypes[])
+{
+  NetlinkAttributeValueType type;
+
+  m_len = start.ReadU16 ();
+  m_type = start.ReadU16 ();
+  type = vtypes[m_type];
+  m_payload.DeserializeWithType (start, type, m_len - 4);
+
+  return GetSerializedSize ();
+}
+
+}; // namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-attribute.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,123 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#ifndef NETLINK_ATTRIBUTE_H
+#define NETLINK_ATTRIBUTE_H
+
+
+#include <stdint.h>
+#include <string>
+#include <ostream>
+#include "ns3/address.h"
+#include "ns3/buffer.h"
+
+namespace ns3 {
+
+/**
+* \brief The Netlink Attribute
+*/
+
+typedef enum NetlinkAttributeValueType_e {
+  UNSPEC, // invalid initial value.
+  U8,
+  U16,
+  U32,
+  U64,
+  STRING,
+  ADDRESS,
+}NetlinkAttributeValueType;
+
+class NetlinkAttributeValue
+{
+public:
+  NetlinkAttributeValue ();
+  NetlinkAttributeValue(NetlinkAttributeValueType type, uint8_t v);
+  NetlinkAttributeValue(NetlinkAttributeValueType type, uint16_t v);
+  NetlinkAttributeValue(NetlinkAttributeValueType type, uint32_t v);
+  NetlinkAttributeValue(NetlinkAttributeValueType type, uint64_t v);
+  NetlinkAttributeValue(NetlinkAttributeValueType type, std::string v);
+  NetlinkAttributeValue(NetlinkAttributeValueType type, Address v);
+  
+  void Serialize (Buffer::Iterator& start) const;
+  uint32_t DeserializeWithType (Buffer::Iterator& start, NetlinkAttributeValueType type, uint16_t remaining);
+  uint32_t GetSerializedSize (void) const;
+  uint32_t GetSize (void) const;
+  void Print (std::ostream &os) const;
+
+  void SetType(NetlinkAttributeValueType type);
+  NetlinkAttributeValueType GetType (void) const;
+  void SetAddress (Address value);
+  void SetString (std::string value);
+  void SetU64 (uint64_t value);
+  void SetU32 (uint32_t value);
+  void SetU16 (uint16_t value);
+  void SetU8 (uint8_t value);
+  Address GetAddress (void) const;
+  std::string GetString (void) const;
+  uint64_t GetU64(void) const;
+  uint32_t GetU32 (void) const;
+  uint16_t GetU16 (void) const;
+  uint8_t GetU8 (void) const;
+
+private:
+  NetlinkAttributeValueType m_type;
+  uint64_t m_u64;
+  uint32_t m_u32;
+  uint16_t m_u16;
+  uint8_t m_u8;
+  std::string m_string;
+  Address m_address;
+};
+
+struct NetlinkAttribute
+{
+public:
+  NetlinkAttribute();
+  NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint8_t payload);
+  NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint16_t payload);
+  NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint32_t payload);
+  NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  uint64_t payload);
+  NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  std::string payload);
+  NetlinkAttribute (uint16_t type, NetlinkAttributeValueType payloadtype,  Address payload);
+
+  //static TypeId GetTypeId (void);
+  //virtual TypeId GetInstanceTypeId (void) const;
+  void Print (std::ostream &os) const;
+  uint32_t GetSerializedSize (void) const;
+  void Serialize (Buffer::Iterator& start) const;
+  uint32_t Deserialize (Buffer::Iterator& start, NetlinkAttributeValueType vtypes[]);
+
+  void SetAttrLen(uint16_t v);
+  void SetAttrType(uint16_t v);
+  void SetAttrPayload(NetlinkAttributeValue v);
+  uint16_t GetAttrLen() const;
+  uint16_t GetAttrType() const;
+  NetlinkAttributeValue GetAttrPayload() const;
+
+private:
+  static const int NETLINK_MSG_ATTR_SIZE = 4; /* size of the nlattr field*/
+  uint16_t m_len;
+  uint16_t m_type; 
+  NetlinkAttributeValue m_payload;
+};
+
+}; // namespace ns3
+
+#endif /* NETLINK_ATTRIBUTE_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-ipv6-routing-table.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,365 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 WIDE Project
+ *
+ * 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: Hajime Tazaki <tazaki@sfc.wide.ad.jp>
+ */
+
+#include "ns3/log.h"
+#include "ns3/packet.h"
+#include "ns3/net-device.h"
+#include "ns3/ipv6-address.h"
+#include "ns3/ipv6-route.h"
+#include "ns3/ipv6-routing-table-entry.h"
+#include "netlink-ipv6-routing-table.h"
+
+NS_LOG_COMPONENT_DEFINE("NetlinkIpv6RoutingTable");
+
+namespace ns3
+{
+
+  NS_OBJECT_ENSURE_REGISTERED (NetlinkIpv6RoutingTable);
+
+  TypeId 
+  NetlinkIpv6RoutingTable::GetTypeId (void)
+  {
+    static TypeId tid = TypeId ("ns3::NetlinkIpv6RoutingTable")
+      .SetParent<Ipv6RoutingProtocol> ();
+    return tid;
+  }
+
+  TypeId 
+  NetlinkIpv6RoutingTable::GetInstanceTypeId (void) const
+  {
+    return GetTypeId ();
+  }
+
+
+  NetlinkIpv6RoutingTable::NetlinkIpv6RoutingTable()
+  {
+    NS_LOG_FUNCTION_NOARGS();
+  }
+
+  void NetlinkIpv6RoutingTable::AddRouteTo(Ipv6Address network, Ipv6Prefix networkPrefix, Ipv6Address nextHop, uint32_t interface, Ipv6Address prefixToUse)
+  {
+    NS_LOG_FUNCTION(this << network << networkPrefix << nextHop << interface << prefixToUse);
+    Ipv6RoutingTableEntry* route = new Ipv6RoutingTableEntry ();
+    *route=Ipv6RoutingTableEntry::CreateNetworkRouteTo(network, networkPrefix, nextHop, interface, prefixToUse);
+    m_RouteTable.push_back(route);
+  }
+
+
+  bool NetlinkIpv6RoutingTable::HasNetworkDest(Ipv6Address network, uint32_t interfaceIndex)
+  {
+    NS_LOG_FUNCTION(this << network << interfaceIndex);
+
+    /* in the network table */
+    for (std::list<Ipv6RoutingTableEntry *>::iterator j=m_RouteTable.begin(); j!=m_RouteTable.end();j++)
+    {
+      NS_ASSERT((*j)->IsNetwork());
+      Ipv6Prefix prefix= (*j)->GetDestNetworkPrefix();
+      Ipv6Address entry=(*j)->GetDestNetwork();
+
+      if (prefix.IsMatch(network, entry) && (*j)->GetInterface() == interfaceIndex)
+      {
+        return true;
+      }
+    }
+
+    /* beuh!!! not route at all */
+    return false;
+  }
+
+  Ptr<Ipv6Route> NetlinkIpv6RoutingTable::Lookup (Ipv6Address dst, uint32_t interface)
+  {
+    NS_LOG_FUNCTION(this << dst);
+    Ipv6RoutingTableEntry *longest = NULL;
+    Ptr<Ipv6Route> rtentry = 0;
+
+    if (dst == Ipv6Address::GetAllNodesMulticast () || dst.IsSolicitedMulticast () || 
+        dst == Ipv6Address::GetAllRoutersMulticast () || dst == Ipv6Address::GetAllHostsMulticast ())
+      {
+        NS_ASSERT_MSG (interface > 0, "Try to send on link-local multicast address, and no interface index is given!");
+        rtentry = Create<Ipv6Route> ();
+        rtentry->SetSource (m_ipv6->GetAddress (interface, 0).GetAddress ());
+        rtentry->SetDestination (dst);
+        rtentry->SetGateway (Ipv6Address::GetZero ());
+        rtentry->SetOutputDevice (m_ipv6->GetNetDevice (interface));
+        return rtentry;
+      }
+
+    /* or in the network table */
+    for (std::list<Ipv6RoutingTableEntry *>::iterator j=m_RouteTable.begin(); j!=m_RouteTable.end();j++)
+    {
+      Ipv6Prefix prefix= (*j)->GetDestNetworkPrefix();
+      Ipv6Address entry=(*j)->GetDestNetwork();
+
+      if (prefix.IsMatch(dst, entry))
+      {
+        // Longest Match!
+        if(longest == NULL ||
+           longest->GetDestNetworkPrefix().PrefixLen() <
+           (*j)->GetDestNetworkPrefix().PrefixLen() )
+        longest = *j;
+      }
+    }
+    if(longest)
+      {
+        Ptr<Ipv6Route> rtentry = 0;
+        rtentry = Create<Ipv6Route> ();
+        rtentry->SetDestination (dst);
+        rtentry->SetGateway (longest->GetGateway());
+        rtentry->SetOutputDevice (m_ipv6->GetNetDevice (longest->GetInterface ()));
+        return rtentry;
+      }
+
+    /* beuh!!! not route at all */
+    return 0;
+  }
+
+  void NetlinkIpv6RoutingTable::DoDispose ()
+  {
+    NS_LOG_FUNCTION_NOARGS();
+    for (std::list<Ipv6RoutingTableEntry *>::iterator j = m_RouteTable.begin ();  j != m_RouteTable.end (); j = m_RouteTable.erase (j))
+    {
+      delete (*j);
+    }
+    Ipv6RoutingProtocol::DoDispose ();
+  }
+
+
+  uint32_t NetlinkIpv6RoutingTable::GetNRoutes ()
+  {
+    NS_LOG_FUNCTION_NOARGS();
+    return m_RouteTable.size ();
+  }
+
+
+  Ipv6RoutingTableEntry* NetlinkIpv6RoutingTable::GetRoute (uint32_t index)
+  {
+    NS_LOG_FUNCTION(this << index);
+    uint32_t tmp = 0;
+    for (std::list<Ipv6RoutingTableEntry *>::iterator j = m_RouteTable.begin (); j != m_RouteTable.end (); j++)
+    {
+      if (tmp == index)
+      {
+        return *j;
+      }
+      tmp++;
+    }
+    NS_ASSERT (false);
+    // quiet compiler.
+    return 0;
+  }
+
+  void NetlinkIpv6RoutingTable::RemoveRoute (uint32_t index)
+  {
+    NS_LOG_FUNCTION(this << index);
+    uint32_t tmp = 0;
+    for (std::list<Ipv6RoutingTableEntry *>::iterator j = m_RouteTable.begin ();j != m_RouteTable.end (); j++)
+    {
+      if (tmp == index)
+      {
+        delete *j;
+        m_RouteTable.erase (j);
+        return;
+      }
+      tmp++;
+    }
+    NS_ASSERT (false);
+  }
+
+  void NetlinkIpv6RoutingTable::RemoveRoute(Ipv6Address network)
+  {
+    NS_LOG_FUNCTION(this << network);
+    for (std::list<Ipv6RoutingTableEntry *>::iterator i = m_RouteTable.begin (); i != m_RouteTable.end (); i++)
+    {
+      if(network == (*i)->GetDest())
+      {
+        delete *i;
+        m_RouteTable.erase (i);
+        return;
+      }
+    }
+  }
+
+  void NetlinkIpv6RoutingTable::RemoveRoute(Ipv6Address network, Ipv6Prefix prefix, uint32_t ifIndex)
+  {
+    NS_LOG_FUNCTION(this << network << prefix << ifIndex);
+    for (std::list<Ipv6RoutingTableEntry *>::iterator i = m_RouteTable.begin (); i != m_RouteTable.end (); i++)
+    {
+      if(network == (*i)->GetDest() and (*i)->GetInterface() == ifIndex)
+      {
+        delete *i;
+        m_RouteTable.erase (i);
+        return;
+      }
+    }
+  }
+
+  Ptr<Ipv6Route> NetlinkIpv6RoutingTable::RouteOutput (Ptr<Packet> p, const Ipv6Header &header, uint32_t oif, Socket::SocketErrno &sockerr)
+  {
+    NS_LOG_FUNCTION (this << header << oif);
+    Ipv6Address destination = header.GetDestinationAddress ();
+    Ptr<Ipv6Route> rtentry = 0;
+
+    if (destination.IsMulticast ())
+      {
+        // Note:  Multicast routes for outbound packets are stored in the
+        // normal unicast table.  An implication of this is that it is not
+        // possible to source multicast datagrams on multiple interfaces.
+        // This is a well-known property of sockets implementation on
+        // many Unix variants.
+        // So, we just log it and fall through to LookupStatic ()
+        NS_LOG_LOGIC ("RouteOutput ()::Multicast destination");
+      }
+  
+    rtentry = Lookup (destination, oif);
+    if (rtentry)
+      {
+        sockerr = Socket::ERROR_NOTERROR;
+      }
+    else
+      {
+        sockerr = Socket::ERROR_NOROUTETOHOST;
+      }
+    return rtentry;
+  }
+
+  bool NetlinkIpv6RoutingTable::RouteInput(Ptr<const Packet> packet, const Ipv6Header &ipHeader, Ptr<const NetDevice> idev,
+                             UnicastForwardCallback ucb, MulticastForwardCallback mcb,
+                             LocalDeliverCallback lcb, ErrorCallback ecb)
+
+  {
+    NS_LOG_FUNCTION(this << idev << &ipHeader << packet << &ucb);
+
+    NS_LOG_LOGIC("source = " << ipHeader.GetSourceAddress());
+    NS_LOG_LOGIC("destination = " << ipHeader.GetDestinationAddress());
+
+    if (ipHeader.GetDestinationAddress().IsMulticast())
+    {
+      NS_LOG_LOGIC ("Multicast destination");
+      return false;
+    }
+
+    /* check if we have a unicast route */
+    NS_LOG_LOGIC("Unicast destination");
+    Ptr<Ipv6Route> route=Lookup(ipHeader.GetDestinationAddress(), 0);
+    if (route)
+    {
+      NS_LOG_LOGIC("found route to destination");
+      ucb(route, packet, ipHeader);
+
+      return true;
+    }
+    else
+    {
+      NS_LOG_LOGIC("not found route to destination");
+      return false; /* maybe other routing protocols can handle this route request */
+    }
+  }
+
+  bool NetlinkIpv6RoutingTable::RequestIfIndex(Ipv6Address destination, uint32_t & ifIndex)
+  {
+    NS_LOG_FUNCTION(this << destination << &ifIndex);
+
+    if (destination.IsMulticast())
+    {
+      NS_LOG_LOGIC("Multicast destination");
+      return false;
+    }
+
+    /* see if this is a unicast packet we have a route for */
+    NS_LOG_LOGIC("Unicast destination");
+    Ptr<Ipv6Route> route=Lookup(destination, 0);
+
+    if (route)
+    {
+      ifIndex=route->GetOutputDevice()->GetIfIndex();
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+#if 0
+  bool NetlinkIpv6RoutingTable::RequestIfIndex(Ipv6Address destination, uint32_t & ifIndex, Ipv6Address& prefixToUse)
+  {
+    NS_LOG_FUNCTION(this << destination << &ifIndex);
+
+    if (destination.IsMulticast())
+    {
+      NS_LOG_LOGIC("Multicast destination");
+      return false;
+    }
+
+    /* see if this is a unicast packet we have a route for */
+    NS_LOG_LOGIC("Unicast destination " << destination );
+    Ptr<Ipv6Route> route=Lookup(destination, 0);
+
+    if (route)
+    {
+      ifIndex=route->GetOutputDevice()->GetInterface();
+      prefixToUse=route->GetPrefixToUse();
+      return true;
+    }
+    else
+    {
+      return false;
+    }
+  }
+#endif
+
+  void NetlinkIpv6RoutingTable::NotifyInterfaceUp (uint32_t interface)
+  {
+    return;
+  }
+
+  void NetlinkIpv6RoutingTable::NotifyInterfaceDown (uint32_t interface)
+  {
+    return;
+  }
+
+  void NetlinkIpv6RoutingTable::NotifyAddAddress (uint32_t interface, Ipv6InterfaceAddress address)
+  {
+    return;
+  }
+
+  void NetlinkIpv6RoutingTable::NotifyRemoveAddress (uint32_t interface, Ipv6InterfaceAddress address)
+  {
+    return;
+  }
+
+  void NetlinkIpv6RoutingTable::NotifyAddRoute (Ipv6Address dst, Ipv6Prefix mask, Ipv6Address nextHop, uint32_t interface, Ipv6Address prefixToUse)
+  {
+    return;
+  }
+
+  void NetlinkIpv6RoutingTable::NotifyRemoveRoute (Ipv6Address dst, Ipv6Prefix mask, Ipv6Address nextHop, uint32_t interface)
+  {
+    return;
+  }
+
+  void NetlinkIpv6RoutingTable::SetIpv6 (Ptr<Ipv6> ipv6)
+  {
+    m_ipv6 = ipv6;
+    return;
+  }
+
+} /* namespace ns3 */
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-ipv6-routing-table.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,168 @@
+/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2009 WIDE Project
+ *
+ * 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: Hajime Tazaki <tazaki@sfc.wide.ad.jp>
+ */
+
+#ifndef NETLINK_IPV6_ROUTING_TABLE_H
+#define NETLINK_IPV6_ROUTING_TABLE_H
+
+#include <list>
+#include <stdint.h>
+#include "ns3/ipv6-address.h"
+#include "ns3/ipv6-header.h"
+#include "ns3/ptr.h"
+#include "ns3/ipv6.h"
+#include "ns3/ipv6-routing-protocol.h"
+#include "ns3/ipv6-routing-table-entry.h"
+
+namespace ns3
+{
+  class Packet;
+  class NetDevice;
+  class Ipv6Interface;
+  class Ipv6Route;
+  class Node;
+
+  /**
+   * \class Ipv6NetlinkRoutingTable
+   * \brief Routing protocol by Netlink for IP version 6 stacks.
+   * \see Ipv6NetlinkRoutingTable
+   * \see Ipv6L3Protocol::AddRoutingProtocol
+   * \see Ipv6L3Protocol::Ipv6L3Protocol
+   */
+  class NetlinkIpv6RoutingTable : public Ipv6RoutingProtocol
+  {
+  public:
+    static TypeId GetTypeId (void);
+    TypeId GetInstanceTypeId (void) const;
+    /**
+     * \brief Constructor.
+     */
+    NetlinkIpv6RoutingTable();
+
+    /**
+     * \brief Synchronously check to see if we can determine the interface index
+     * that will be used if a packet is sent to this destination.
+     * \param dst The Ipv6Address if the destination of a hypothetical packet. This may be
+     * a multicast group address.
+     * \param ifIndex A reference to the interface index over which a packet
+     * sent to this destination would be sent.
+     * \return true if a route is found to the destination that involves a
+     * single output interface index, false otherwise.
+     */
+    virtual bool RequestIfIndex(Ipv6Address dst, uint32_t & ifIndex);
+
+    /**
+     * \brief Synchronously check to see if we can determine the interface index
+     * that will be used if a packet is sent to this destination.
+     * \param dst The Ipv6Address if the destination of a hypothetical packet. This may be
+     * a multicast group address.
+     * \param ifIndex A reference to the interface index over which a packet
+     * sent to this destination would be sent.
+     * \param prefixToUse prefix to use (i.e for multihoming)
+     * \return true if a route is found to the destination that involves a
+     * single output interface index, false otherwise.
+     */
+#if 0
+    virtual bool RequestIfIndex(Ipv6Address dst, uint32_t & ifIndex, Ipv6Address& prefixToUse);
+#endif
+
+  virtual Ptr<Ipv6Route> RouteOutput (Ptr<Packet> p, const Ipv6Header &header, uint32_t oif, Socket::SocketErrno &sockerr);
+    virtual bool RouteInput  (Ptr<const Packet> p, const Ipv6Header &header, Ptr<const NetDevice> idev, 
+                             UnicastForwardCallback ucb, MulticastForwardCallback mcb, 
+                             LocalDeliverCallback lcb, ErrorCallback ecb);
+  virtual void NotifyInterfaceUp (uint32_t interface);
+  virtual void NotifyInterfaceDown (uint32_t interface);
+  virtual void NotifyAddAddress (uint32_t interface, Ipv6InterfaceAddress address);
+  virtual void NotifyRemoveAddress (uint32_t interface, Ipv6InterfaceAddress address);
+  virtual void NotifyAddRoute (Ipv6Address dst, Ipv6Prefix mask, Ipv6Address nextHop, uint32_t interface, Ipv6Address prefixToUse);
+  virtual void NotifyRemoveRoute (Ipv6Address dst, Ipv6Prefix mask, Ipv6Address nextHop, uint32_t interface);
+  virtual void SetIpv6 (Ptr<Ipv6> ipv6);
+
+
+    /**
+     * \brief Add route
+     * \param network network address
+     * \param networkPrefix network prefix*
+     * \param nextHop next hop address to route the packet
+     * \param interface interface index
+     */
+    void AddRouteTo(Ipv6Address network, Ipv6Prefix networkPrefix, Ipv6Address nextHop, uint32_t interface, Ipv6Address prefixToUse=Ipv6Address("::"));
+
+    /**
+     * \brief Get the number or entries in the routing table.
+     * \return number of entries
+     */
+    uint32_t GetNRoutes();
+
+    /**
+     * \brief Get a specified route.
+     * \param i index
+     * \return the route whose index is i
+     */
+    Ipv6RoutingTableEntry* GetRoute(uint32_t i);
+
+    /**
+     * \brief Remove a route from the routing table.
+     * \param i index
+     */
+    void RemoveRoute(uint32_t i);
+
+    void RemoveRoute(Ipv6Address network);
+
+    /**
+     * \brief Remove a route from the routing table.
+     * \param network IPv6 network
+     * \param prefix IPv6 prefix
+     * \param ifIndex interface index
+     */
+    void RemoveRoute(Ipv6Address network, Ipv6Prefix prefix, uint32_t ifIndex);
+
+    /**
+     * \brief Lookup in the forwarding table for destination.
+     * \param dest destination address
+     * \return Ipv6Route to route the packet to reach dest address
+     */
+    Ptr<Ipv6Route> Lookup (Ipv6Address dest, uint32_t interface); 
+
+    /**
+     * \brief If the destination is already present in network destination list.
+     * \param dest destination address
+     * \param interfaceIndex interface index
+     * \return true if dest is already in list, false otherwise
+     */
+    bool HasNetworkDest(Ipv6Address dest, uint32_t interfaceIndex);
+
+  protected:
+    /**
+     * \brief Dispose this object.
+     */
+    void DoDispose();
+
+  private:
+    /**
+     * \brief the forwarding table for network.
+     */
+    std::list<Ipv6RoutingTableEntry *> m_RouteTable;
+    Ptr<Ipv6> m_ipv6;
+  };
+
+} /* namespace ns3 */
+
+#endif /* NETLINK_IPV6_ROUTING_TABLE_H */
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-message-route.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,652 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#include "ns3/netlink-message-route.h"
+#include "ns3/netlink-message.h"
+
+namespace ns3 {
+
+/***********************************************************************************
+* \ NetlinkPayload
+***********************************************************************************/
+TypeId 
+NetlinkPayload::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::NetlinkPayload")
+    .SetParent<ObjectBase> ()
+    ;
+  return tid;
+}
+
+
+/***********************************************************************************
+* \ GeneralMessage
+***********************************************************************************/
+
+NS_OBJECT_ENSURE_REGISTERED (GeneralMessage);
+NS_OBJECT_ENSURE_REGISTERED (InterfaceInfoMessage);
+NS_OBJECT_ENSURE_REGISTERED (InterfaceAddressMessage);
+NS_OBJECT_ENSURE_REGISTERED (RouteMessage);
+
+GeneralMessage::GeneralMessage ()
+: m_family(0)
+{}
+GeneralMessage::~GeneralMessage()
+{}
+
+void
+GeneralMessage::SetFamily(uint8_t v)
+{
+  m_family = v;
+}
+uint8_t
+GeneralMessage::GetFamily(void) const
+{
+  return m_family;
+}
+
+TypeId 
+GeneralMessage::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::GeneralMessage")
+    .SetParent<NetlinkPayload> ()
+    .AddConstructor<GeneralMessage> ()
+    ;
+  return tid;
+}
+
+TypeId 
+GeneralMessage::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+void 
+GeneralMessage::Print (std::ostream &os) const
+{
+  os << " ----GeneralMessage ("
+    << "family: " << (uint32_t)m_family << ")"; 
+}
+
+uint32_t 
+GeneralMessage::GetSerializedSize (void) const
+{
+  /* this is the size of an nlmsghdr payload. */
+  return NETLINK_MSG_ALIGN(NETLINK_GENMSG_SIZE);
+}
+
+
+void
+GeneralMessage::Serialize (Buffer::Iterator& start) const
+{
+  start.WriteU8 (m_family);
+  start.WriteU8 (0, 3);
+}
+
+uint32_t
+GeneralMessage::Deserialize (Buffer::Iterator& start)
+{
+  uint8_t buf[3];
+
+  m_family = start.ReadU8 ();
+  start.Read (buf, 3);
+
+  return GetSerializedSize ();
+}
+
+uint32_t
+GeneralMessage::Deserialize (Buffer::Iterator& start, uint32_t len)
+{
+  uint8_t buf[3];
+
+  m_family = start.ReadU8 ();
+  start.Read (buf, 3);
+
+  return GetSerializedSize ();
+}
+
+
+uint32_t
+GeneralMessage::GetNNetlinkAttribute(void)const
+{
+  return m_attributes.size();
+}
+NetlinkAttribute
+GeneralMessage::GetNetlinkAttribute(uint32_t index)const
+{
+  NS_ASSERT(index < GetNNetlinkAttribute());
+
+  return m_attributes[index];
+}
+
+uint32_t
+GeneralMessage::GetAttributeSerializedSize (void) const
+{
+  uint32_t size = 0;
+
+  for (uint32_t i = 0; i < m_attributes.size (); i ++)
+    {
+      size += m_attributes[i].GetSerializedSize();
+    }
+  return size;
+}
+bool
+GeneralMessage::GetAttributeByType(NetlinkAttribute& attr, uint16_t type)
+{
+  for (uint32_t i = 0; i < m_attributes.size(); i ++)
+    {
+      if (type == m_attributes[i].GetAttrType())
+        {
+          attr = m_attributes[i];
+          return true;
+        }
+    }
+  return false;  
+}
+void
+GeneralMessage::AppendAttribute (NetlinkAttribute v)
+{
+  m_attributes.push_back(v);
+}
+
+void
+GeneralMessage::SerializeAttribute (Buffer::Iterator& start) const
+{
+  for (uint32_t i = 0; i < m_attributes.size (); i ++)
+    {
+      m_attributes[i].Serialize (start);
+    }
+}
+
+void
+GeneralMessage::PrintAttribute (std::ostream &os) const
+{
+  for (uint32_t i = 0; i < m_attributes.size (); i ++)
+    {
+      os << " ----Attribute (" << i << "):";
+      m_attributes[i].Print(os);
+    }
+}
+
+/***********************************************************************************
+* \ InterfaceInfoMessage
+***********************************************************************************/
+InterfaceInfoMessage::InterfaceInfoMessage ()
+: m_reserved (0),
+  m_deviceType (0),
+  m_interfaceIndex(0),
+  m_deviceFlags (0),
+  m_changeMask (0)
+{
+  memset((void*)m_attributeTypes, 0, sizeof(m_attributeTypes));
+  m_attributeTypes[IFL_A_UNSPEC] = UNSPEC;
+  m_attributeTypes[IFL_A_ADDRESS] = ADDRESS;
+  m_attributeTypes[IFL_A_BROADCAST] = ADDRESS;
+  m_attributeTypes[IFL_A_IFNAME] = STRING;
+  m_attributeTypes[IFL_A_MTU] = U32;
+  m_attributeTypes[IFL_A_LINK] = U32;
+  m_attributeTypes[IFL_A_QDISC] = U8;
+  m_attributeTypes[IFL_A_STATS] = UNSPEC;
+  m_attributeTypes[IFL_A_COST] = UNSPEC;
+}
+InterfaceInfoMessage::~InterfaceInfoMessage()
+{}
+void
+InterfaceInfoMessage::SetDeviceType (uint16_t type)
+{
+  m_deviceType = type;
+}
+void
+InterfaceInfoMessage::SetInterfaceIndex (int32_t index)
+{
+  m_interfaceIndex = index;
+}
+void
+InterfaceInfoMessage::SetDeviceFlags (uint32_t flags)
+{
+  m_deviceFlags = flags;
+}
+void
+InterfaceInfoMessage::SetChangeMask (uint32_t mask)
+{
+  m_changeMask = mask;
+}
+uint16_t
+InterfaceInfoMessage::GetDeviceType (void) const
+{
+  return m_deviceType;
+}
+int32_t
+InterfaceInfoMessage::GetInterfaceIndex (void) const
+{
+  return m_interfaceIndex;
+}
+uint32_t
+InterfaceInfoMessage::GetDeviceFlags (void) const
+{
+  return m_deviceFlags;
+}
+uint32_t
+InterfaceInfoMessage::GetChangeMask (void) const
+{
+  return m_changeMask;
+}
+TypeId 
+InterfaceInfoMessage::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::InterfaceInfoMessage")
+    .SetParent<GeneralMessage> ()
+    .AddConstructor<InterfaceInfoMessage> ()
+    ;
+  return tid;
+}
+TypeId 
+InterfaceInfoMessage::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+void 
+InterfaceInfoMessage::Print (std::ostream &os) const
+{  
+  os << " ----InterfaceInfoMessage ("
+    << "deviceType: " << m_deviceType << " "
+    << "interfaceIndex: " << m_interfaceIndex << " "
+    << "deviceFlags: " << m_deviceFlags << " "
+    << "changeMask: " << m_changeMask << ")" ;
+  PrintAttribute(os);
+}
+uint32_t 
+InterfaceInfoMessage::GetSerializedSize (void) const
+{
+  return NETLINK_INTERFACE_SIZE + GetAttributeSerializedSize();
+}
+
+void
+InterfaceInfoMessage::Serialize (Buffer::Iterator& start) const
+{
+  start.WriteU8 (m_family);
+  start.WriteU8 (m_reserved);
+  start.WriteU16 (m_deviceType);
+  start.WriteU32 (m_interfaceIndex);
+  start.WriteU32 (m_deviceFlags);
+  start.WriteU32 (m_changeMask);
+
+  SerializeAttribute(start);
+}
+uint32_t
+InterfaceInfoMessage::Deserialize (Buffer::Iterator& start, uint32_t len)
+{
+  m_family = start.ReadU8 ();
+  m_reserved = start.ReadU8 ();
+  m_deviceType = start.ReadU16 ();
+  m_interfaceIndex = start.ReadU32 ();
+  m_deviceFlags = start.ReadU32 ();
+  m_changeMask = start.ReadU32 ();
+
+  len -= NETLINK_INTERFACE_SIZE;
+
+  while (len)
+    {
+      NetlinkAttribute attr;
+
+      len -= attr.Deserialize (start, m_attributeTypes);
+      m_attributes.push_back (attr);
+    }
+
+  return GetSerializedSize ();
+}
+
+
+
+/***********************************************************************************
+* \InterfaceAddressMessage
+***********************************************************************************/
+InterfaceAddressMessage::InterfaceAddressMessage ()
+: m_length (0),
+  m_flags (0),
+  m_scope (0),
+  m_index(0)
+{
+  memset((void*)m_attributeTypes, 0, sizeof(m_attributeTypes));
+  m_attributeTypes[IF_A_UNSPEC] = UNSPEC;
+  m_attributeTypes[IF_A_ADDRESS] = ADDRESS;
+  m_attributeTypes[IF_A_LOCAL] = ADDRESS;
+  m_attributeTypes[IF_A_LABEL] = STRING;
+  m_attributeTypes[IF_A_BROADCAST] = ADDRESS;
+  m_attributeTypes[IF_A_ANYCAST] = ADDRESS;
+  m_attributeTypes[IF_A_CACHEINFO] = UNSPEC;
+  m_attributeTypes[IF_A_MULTICAST] = ADDRESS;
+}
+InterfaceAddressMessage::~InterfaceAddressMessage()
+{
+}
+void
+InterfaceAddressMessage::SetFamily (uint8_t family)
+{
+  m_family = family;
+}
+void
+InterfaceAddressMessage::SetLength (uint8_t length)
+{
+  m_length = length;
+}
+void
+InterfaceAddressMessage::SetFlags (uint8_t flags)
+{
+  m_flags = flags;
+}
+void
+InterfaceAddressMessage::SetScope (uint8_t scope)
+{
+  m_scope = scope;
+}
+void
+InterfaceAddressMessage::SetInterfaceIndex (int32_t index)
+{
+  m_index = index;
+}
+
+uint8_t
+InterfaceAddressMessage::GetFamily (void) const
+{
+  return m_family;
+}
+uint8_t
+InterfaceAddressMessage::GetLength (void) const
+{
+  return m_length;
+}
+uint8_t
+InterfaceAddressMessage::GetFlags (void) const
+{
+  return m_flags;
+}
+uint8_t
+InterfaceAddressMessage::GetScope (void) const
+{
+  return m_scope;
+}
+int32_t
+InterfaceAddressMessage::GetInterfaceIndex (void) const
+{
+  return m_index;
+}
+
+TypeId 
+InterfaceAddressMessage::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::InterfaceAddressMessage")
+    .SetParent<GeneralMessage> ()
+    .AddConstructor<InterfaceAddressMessage> ()
+    ;
+  return tid;
+}
+TypeId 
+InterfaceAddressMessage::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+void 
+InterfaceAddressMessage::Print (std::ostream &os) const
+{  
+  os << " ----InterfaceAddressMessage ("
+    << "family: " << (uint32_t)m_family << " "
+    << "length: " << (uint32_t)m_length << " "
+    << "flags: " << (uint32_t)m_flags << " "
+    << "scope: " << (uint32_t)m_scope << " "
+    << "index: " << m_index << ")";
+  PrintAttribute(os);
+}
+uint32_t 
+InterfaceAddressMessage::GetSerializedSize (void) const
+{
+  return NETLINK_ADDRESS_SIZE + GetAttributeSerializedSize();
+}
+
+void
+InterfaceAddressMessage::Serialize (Buffer::Iterator& start) const
+{
+  start.WriteU8 (m_family);
+  start.WriteU8 (m_length);
+  start.WriteU8 (m_flags);
+  start.WriteU8 (m_scope);
+  start.WriteU32 (m_index);
+
+  SerializeAttribute(start);
+}
+
+uint32_t
+InterfaceAddressMessage::Deserialize (Buffer::Iterator& start, uint32_t len)
+{
+  m_family = start.ReadU8 ();
+  m_length = start.ReadU8 ();
+  m_flags = start.ReadU8 ();
+  m_scope = start.ReadU8 ();
+  m_index = start.ReadU32 ();
+
+  len -= NETLINK_ADDRESS_SIZE;
+
+  while (len)
+    {
+      NetlinkAttribute attr;
+
+      len -= attr.Deserialize (start, m_attributeTypes);
+      m_attributes.push_back (attr);
+    }
+
+  return GetSerializedSize ();
+}
+
+
+
+/***********************************************************************************
+* \ RouteMessage
+***********************************************************************************/
+RouteMessage::RouteMessage ()
+: m_dstLen (0),
+  m_srcLen (0),
+  m_tos (0),
+  m_tableId (0),
+  m_protocol(0),
+  m_scope (0),
+  m_type (0),
+  m_flags (0)
+{
+  memset((void*)m_attributeTypes, 0, sizeof(m_attributeTypes));
+  m_attributeTypes[RT_A_UNSPEC] = UNSPEC;
+  m_attributeTypes[RT_A_DST] = ADDRESS;
+  m_attributeTypes[RT_A_SRC] = ADDRESS;
+  m_attributeTypes[RT_A_IIF] = U32;
+  m_attributeTypes[RT_A_OIF] = U32;
+  m_attributeTypes[RT_A_GATEWAY] = ADDRESS;
+  m_attributeTypes[RT_A_PRIORITY] = U8;
+  m_attributeTypes[RT_A_PREFSRC] = ADDRESS;
+  m_attributeTypes[RT_A_METRICS] = UNSPEC;
+  //others default value UNSPEC
+}
+RouteMessage::~RouteMessage ()
+{}
+
+void
+RouteMessage::SetFamily (uint8_t v)
+{
+  m_family = v;
+}
+void
+RouteMessage::SetDstLength (uint8_t v)
+{
+  m_dstLen = v;
+}
+void
+RouteMessage::SetSrcLength (uint8_t v)
+{
+  m_srcLen = v;
+}
+void
+RouteMessage::SetTos (uint8_t v)
+{
+  m_tos = v;
+}
+void
+RouteMessage::SetTableId (uint8_t v)
+{
+  m_tableId = v;
+}
+void
+RouteMessage::SetProtocol (uint8_t v)
+{
+  m_protocol = v;
+}
+void
+RouteMessage::SetScope (uint8_t v)
+{
+  m_scope = v;
+}
+void
+RouteMessage::SetType (uint8_t v)
+{
+  m_type = v;
+}
+void
+RouteMessage::SetFlags (uint32_t v)
+{
+  m_flags = v;
+}
+uint8_t
+RouteMessage::GetFamily (void) const
+{
+  return m_family;
+}
+uint8_t
+RouteMessage::GetDstLength (void) const
+{
+  return m_dstLen;
+}
+uint8_t
+RouteMessage::GetSrcLength (void) const
+{
+  return m_srcLen;
+}
+uint8_t
+RouteMessage::GetTos (void) const
+{
+  return m_tos;
+}
+uint8_t
+RouteMessage::GetTableId (void) const
+{
+  return m_tableId;
+}
+uint8_t
+RouteMessage::GetProtocol(void) const
+{
+  return m_protocol;
+}
+uint8_t
+RouteMessage::GetType (void) const
+{
+  return m_type;
+}
+uint8_t
+RouteMessage::GetScope (void) const
+{
+  return m_scope;
+}
+uint32_t
+RouteMessage::GetFlags (void) const
+{
+  return m_flags;
+}
+
+TypeId 
+RouteMessage::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::RouteMessage")
+    .SetParent<GeneralMessage> ()
+    .AddConstructor<RouteMessage> ()
+    ;
+  return tid;
+}
+TypeId 
+RouteMessage::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+void 
+RouteMessage::Print (std::ostream &os) const
+{  
+  os << " ----RouteMessage ("
+    << "family: " << (uint32_t)m_family << " "
+    << "dstLen: " << (uint32_t)m_dstLen << " "
+    << "srcLen: " << (uint32_t)m_srcLen << " "
+    << "tos: " << (uint32_t)m_tos << " "
+    << "tableId: " << (uint32_t)m_tableId << " "
+    << "protocol: " << (uint32_t)m_protocol << " "
+    << "scope: " << (uint32_t)m_scope << " "
+    << "type: " << (uint32_t)m_type << " "
+    << "flags: " << m_flags<< ")" ;
+  PrintAttribute(os);
+}
+uint32_t 
+RouteMessage::GetSerializedSize (void) const
+{
+  return NETLINK_ROUTE_SIZE + GetAttributeSerializedSize();
+}
+
+void
+RouteMessage::Serialize (Buffer::Iterator& start) const
+{
+  start.WriteU8 (m_family);
+  start.WriteU8 (m_dstLen);
+  start.WriteU8 (m_srcLen);
+  start.WriteU8 (m_tos);
+  start.WriteU8 (m_tableId);
+  start.WriteU8 (m_protocol);
+  start.WriteU8 (m_scope);
+  start.WriteU8 (m_type);
+  start.WriteU32 (m_flags);
+
+  SerializeAttribute(start);
+}
+uint32_t
+RouteMessage::Deserialize (Buffer::Iterator& start, uint32_t len)
+{
+  m_family = start.ReadU8 ();
+  m_dstLen = start.ReadU8 ();
+  m_srcLen = start.ReadU8 ();
+  m_tos = start.ReadU8 ();
+  m_tableId = start.ReadU8 ();
+  m_protocol = start.ReadU8 ();
+  m_scope = start.ReadU8 ();
+  m_type = start.ReadU8 ();
+  m_flags = start.ReadU32 ();
+
+  len -= NETLINK_ROUTE_SIZE;
+
+  while (len)
+    {
+      NetlinkAttribute attr;
+
+      len -= attr.Deserialize (start, m_attributeTypes);
+      m_attributes.push_back (attr);
+    }
+
+  return GetSerializedSize ();
+}
+}; // namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-message-route.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,398 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#ifndef NETLINK_MESSAGE_ROUTE_H
+#define NETLINK_MESSAGE_ROUTE_H
+
+#include "ns3/object-base.h"
+#include "ns3/address.h"
+#include "ns3/netlink-attribute.h"
+#include <string>
+
+namespace ns3 {
+
+/*
+* this file define some netlink message of NETLINK_ROUTE protocol,
+* there are mainly three types:interface address, interface info, route entry
+* just implemented them for quagga porting.
+*/
+  
+
+
+/**
+* \Types of messages,here we only define the route message types quagga used
+*/
+enum NetlinkRtmType_e
+{
+  NETLINK_RTM_BASE	= 16,
+
+  NETLINK_RTM_NEWLINK = 16,
+  NETLINK_RTM_DELLINK,
+  NETLINK_RTM_GETLINK,
+  NETLINK_RTM_SETLINK,
+
+  NETLINK_RTM_NEWADDR = 20,
+  NETLINK_RTM_DELADDR,
+  NETLINK_RTM_GETADDR,
+
+  NETLINK_RTM_NEWROUTE = 24,
+  NETLINK_RTM_DELROUTE,
+  NETLINK_RTM_GETROUTE,
+
+  NETLINK_RTM_MAX,
+};  
+
+/**
+* \Types of netlink groups,here we only define types quagga used
+*/
+enum NetlinkRtmGroup_e
+{
+  NETLINK_RTM_GRP_LINK = 1,
+  NETLINK_RTM_GRP_IPV4_IFADDR = 0x10,
+  NETLINK_RTM_GRP_IPV4_ROUTE = 0x40,
+  RTMGRP_IPV6_IFADDR = 0x100,
+  RTMGRP_IPV6_ROUTE = 0x400,
+};
+
+class NetlinkPayload :public ObjectBase
+{
+public:
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const = 0;
+  virtual void Serialize (Buffer::Iterator& start) const = 0;
+  virtual void Print (std::ostream &os) const = 0;
+  virtual uint32_t GetSerializedSize (void) const = 0;
+};
+
+/***
+*		General form of address family dependent message.
+**
+  struct rtgenmsg
+  {
+    unsigned char		rtgen_family;
+  };
+**/
+
+class GeneralMessage : public NetlinkPayload
+{
+public:
+  GeneralMessage ();
+  virtual ~GeneralMessage();
+
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const;
+  virtual void Serialize (Buffer::Iterator& start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator& start);
+  virtual uint32_t Deserialize (Buffer::Iterator& start, uint32_t len);
+  virtual void Print (std::ostream &os) const;
+  virtual uint32_t GetSerializedSize (void) const;
+
+  
+  virtual uint32_t GetNNetlinkAttribute(void)const;
+  virtual NetlinkAttribute GetNetlinkAttribute(uint32_t index)const;
+  virtual void AppendAttribute (NetlinkAttribute v);
+  virtual void SerializeAttribute (Buffer::Iterator& start) const;
+  virtual void PrintAttribute (std::ostream &os) const;
+  virtual uint32_t GetAttributeSerializedSize (void) const;
+  virtual bool GetAttributeByType(NetlinkAttribute& attr, uint16_t type);
+
+
+  void SetFamily(uint8_t v);
+  uint8_t GetFamily(void) const;
+
+private:
+  static const int NETLINK_GENMSG_SIZE = 1; /* size of the struct rtgenmsg */  
+protected:
+  uint8_t m_family;   //always set to AF_UNSPEC
+  //attribute can exist or not
+  std::vector<NetlinkAttribute> m_attributes;
+};
+
+
+
+/**
+* \brief Link layer specific messages
+*
+* struct ifinfomsg
+* passes link level specific information, not dependent
+* on network protocol.
+*
+  struct ifinfomsg
+  {
+    unsigned char	ifi_family;
+    unsigned char	__ifi_pad;
+    unsigned short	ifi_type;
+    int		ifi_index;	
+    unsigned	ifi_flags;
+    unsigned	ifi_change;
+  };
+*/
+class InterfaceInfoMessage : public GeneralMessage
+{
+public:
+  InterfaceInfoMessage ();
+  virtual ~InterfaceInfoMessage();
+
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const;
+  virtual void Serialize (Buffer::Iterator& start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator& start, uint32_t len);
+  virtual void Print (std::ostream &os) const;
+  virtual uint32_t GetSerializedSize (void) const;
+
+  enum IflAttr_e
+  {
+    IFL_A_UNSPEC,
+    IFL_A_ADDRESS,
+    IFL_A_BROADCAST,
+    IFL_A_IFNAME,
+    IFL_A_MTU,
+    IFL_A_LINK,
+    IFL_A_QDISC,
+    IFL_A_STATS,
+    IFL_A_COST,
+    IFL_A_PRIORITY,
+    IFL_A_MASTER,
+    IFL_A_WIRELESS,		
+    IFL_A_PROTINFO,
+    IFL_A_TXQLEN,
+    IFL_A_MAP,
+    IFL_A_WEIGHT,
+    IFL_A_OPERSTATE,
+    IFL_A_LINKMODE,
+    IFL_A_MAX,
+  };
+
+  enum Type_e{
+    UP = 1,
+    BROADCAST = 2,
+    DBG = 4,
+  };
+
+  void SetDeviceType (uint16_t type);
+  void SetInterfaceIndex (int32_t index);
+  void SetDeviceFlags (uint32_t index);
+  void SetChangeMask (uint32_t mask);
+
+  uint16_t GetDeviceType (void) const;
+  int32_t GetInterfaceIndex (void) const;
+  uint32_t GetDeviceFlags (void) const;
+  uint32_t GetChangeMask (void) const;
+private:
+  static const int NETLINK_INTERFACE_SIZE = 16; /* size of the struct ifinfomsg */
+  uint8_t m_reserved; //not used
+  uint16_t m_deviceType;
+  int32_t m_interfaceIndex;
+  uint32_t m_deviceFlags;
+  uint32_t m_changeMask;
+  NetlinkAttributeValueType m_attributeTypes[IFL_A_MAX];
+};
+
+
+
+
+/**
+* \brief Interface address.
+*
+  struct ifaddrmsg
+  {
+  unsigned char	ifa_family;
+  unsigned char	ifa_prefixlen;
+  unsigned char	ifa_flags;
+  unsigned char	ifa_scope;
+  int		ifa_index;
+  };
+*/
+
+class InterfaceAddressMessage : public GeneralMessage
+{
+public:
+  InterfaceAddressMessage ();
+  virtual ~InterfaceAddressMessage();
+
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const;
+  virtual void Serialize (Buffer::Iterator& start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator& start, uint32_t len);
+  virtual void Print (std::ostream &os) const;
+  virtual uint32_t GetSerializedSize (void) const;
+
+  enum IfAttr_e
+  {
+    IF_A_UNSPEC,
+    IF_A_ADDRESS,
+    IF_A_LOCAL,
+    IF_A_LABEL,
+    IF_A_BROADCAST,
+    IF_A_ANYCAST,
+    IF_A_CACHEINFO,
+    IF_A_MULTICAST,
+    IF_A_MAX
+  };
+
+  enum {
+    F_SECONDARY = 0x01,
+    F_PERMANENT = 0x80,
+    F_DEPRECATED = 0x20,
+    F_TENTATIVE = 0x40
+  };
+  enum {
+    SCOPE_UNIVERSE = 0,
+    SCOPE_SITE = 200,
+    SCOPE_LINK = 253,
+    SCOPE_HOST = 254
+  };
+
+
+  void SetFamily (uint8_t family);
+  void SetLength (uint8_t length);
+  void SetFlags (uint8_t flags);
+  void SetScope (uint8_t scope);
+  void SetInterfaceIndex (int32_t index);
+
+  uint8_t GetFamily (void) const;
+  uint8_t GetLength (void) const;
+  uint8_t GetFlags (void) const;
+  uint8_t GetScope (void) const;
+  int32_t GetInterfaceIndex (void) const;
+
+private:
+  static const int NETLINK_ADDRESS_SIZE = 8; /* size of the struct ifaddrmsg */
+  uint8_t m_length;
+  uint8_t m_flags;
+  uint8_t m_scope;
+  int32_t m_index;
+  NetlinkAttributeValueType m_attributeTypes[IF_A_MAX];
+};
+
+
+
+
+/**
+* \brief Definitions used in routing table administration.
+*
+  struct rtmsg
+  {
+    unsigned char		rtm_family;
+    unsigned char		rtm_dst_len;
+    unsigned char		rtm_src_len;
+    unsigned char		rtm_tos;
+
+    unsigned char		rtm_table;	// Routing table id 
+    unsigned char		rtm_protocol;	//Routing protocol; 
+    unsigned char		rtm_scope;	
+    unsigned char		rtm_type;	
+
+    unsigned		rtm_flags;
+  };
+*/
+
+class RouteMessage : public GeneralMessage
+{
+public:
+  RouteMessage ();
+  virtual ~RouteMessage ();
+
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const;
+  virtual void Serialize (Buffer::Iterator& start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator& start, uint32_t len);
+  virtual void Print (std::ostream &os) const;
+  virtual uint32_t GetSerializedSize (void) const;
+
+  uint8_t GetFamily (void) const;
+  uint8_t GetDstLength (void) const;
+  uint8_t GetSrcLength (void) const;
+  uint8_t GetTos (void) const;
+  uint8_t GetTableId (void) const;
+  uint8_t GetProtocol(void) const;
+  uint8_t GetType (void) const;
+  uint8_t GetScope (void) const;
+  uint32_t GetFlags (void) const;
+  void SetFamily (uint8_t v);
+  void SetDstLength (uint8_t v);
+  void SetSrcLength (uint8_t v);
+  void SetTos (uint8_t v);
+  void SetTableId (uint8_t v);
+  void SetProtocol (uint8_t v);
+  void SetScope (uint8_t v);
+  void SetType (uint8_t v);
+  void SetFlags (uint32_t v);
+
+  enum RtProtocol_e
+  {
+    RT_PROT_UNSPEC = 0,
+  };
+
+  enum RtFlags_e
+  {
+    RT_F_CLONED	=	0x200,
+  };
+
+  enum RtScope_e
+  {
+    RT_SCOPE_UNIVERSE=0,
+    RT_SCOPE_LINK = 253,
+  };
+
+  enum RtClass_e
+  {
+    RT_TABLE_UNSPEC = 0,
+    RT_TABLE_MAIN = 254,
+  };
+
+  enum RtAttr_e
+  {
+    RT_A_UNSPEC,
+    RT_A_DST,
+    RT_A_SRC,
+    RT_A_IIF,
+    RT_A_OIF,
+    RT_A_GATEWAY,
+    RT_A_PRIORITY,
+    RT_A_PREFSRC,
+    RT_A_METRICS,
+    RT_A_MULTIPATH,
+    RT_A_PROTOINFO,
+    RT_A_FLOW,
+    RT_A_CACHEINFO,
+    RT_A_SESSION,
+    RT_A_MP_ALGO,
+    RT_A_TABLE,
+    RT_A_MAX
+  };
+
+
+private:
+  static const int NETLINK_ROUTE_SIZE = 12; /* size of the struct rtmsg */
+  uint8_t m_dstLen;
+  uint8_t m_srcLen;
+  uint8_t m_tos;
+  uint8_t m_tableId;
+  uint8_t m_protocol;
+  uint8_t m_scope;
+  uint8_t m_type;
+  uint32_t m_flags;
+  NetlinkAttributeValueType m_attributeTypes[RT_A_MAX];
+};
+
+}; // namespace ns3
+
+#endif /* NETLINK_MESSAGE_ROUTE_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-message.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,658 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#include "ns3/netlink-message.h"
+#include "ns3/address-utils.h"
+#include "ns3/log.h"
+
+NS_LOG_COMPONENT_DEFINE ("NetlinkMessage");
+namespace ns3 {
+
+/***********************************************************************************
+* \ NetlinkMessageHeader
+***********************************************************************************/
+NS_OBJECT_ENSURE_REGISTERED (NetlinkMessageHeader);
+NS_OBJECT_ENSURE_REGISTERED (NetlinkMessage);
+
+NetlinkMessageHeader::NetlinkMessageHeader ()
+: m_nlmsgLen (16),
+  m_nlmsgType (0),
+  m_nlmsgFlags (0),
+  m_nlmsgSeq (0),
+  m_nlmsgPid (0)
+{}
+
+NetlinkMessageHeader::NetlinkMessageHeader (uint16_t type, uint16_t flags, uint32_t seq, uint32_t pid)
+: m_nlmsgLen (16),
+  m_nlmsgType (type),
+  m_nlmsgFlags (flags),
+  m_nlmsgSeq (seq),
+  m_nlmsgPid (pid)
+{}
+
+void
+NetlinkMessageHeader::SetMsgLen (uint32_t v)
+{
+  m_nlmsgLen = v;
+}
+void
+NetlinkMessageHeader::SetMsgFlags (uint16_t v)
+{
+  m_nlmsgFlags = v;
+}
+void
+NetlinkMessageHeader::SetMsgType (uint16_t v)
+{
+  m_nlmsgType = v;
+}
+void
+NetlinkMessageHeader::SetMsgSeq (uint32_t v)
+{
+  m_nlmsgSeq = v;
+}
+void
+NetlinkMessageHeader::SetMsgPid (uint32_t v)
+{
+  m_nlmsgPid = v;
+}
+uint16_t
+NetlinkMessageHeader::GetMsgFlags (void) const
+{
+  return m_nlmsgFlags;
+}
+uint32_t 
+NetlinkMessageHeader::GetMsgLen (void) const
+{
+  return m_nlmsgLen;
+}
+uint16_t 
+NetlinkMessageHeader::GetMsgType (void) const
+{
+  return m_nlmsgType;
+}
+uint32_t
+NetlinkMessageHeader::GetMsgSeq (void) const
+{
+  return m_nlmsgSeq;
+}
+uint32_t 
+NetlinkMessageHeader::GetMsgPid (void) const
+{
+  return m_nlmsgPid;
+}
+uint32_t
+NetlinkMessageHeader::GetHeaderSize ()
+{
+  return NETLINK_MSG_HEADER_SIZE;
+}
+uint32_t
+NetlinkMessageHeader::GetPayloadSize (void) const
+{
+  return NETLINK_MSG_ALIGN(m_nlmsgLen - NETLINK_MSG_HEADER_SIZE);
+}
+
+TypeId 
+NetlinkMessageHeader::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::NetlinkMessageHeader")
+    .SetParent<Header> ()
+    .AddConstructor<NetlinkMessageHeader> ()
+    ;
+  return tid;
+}
+TypeId 
+NetlinkMessageHeader::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+void 
+NetlinkMessageHeader::Print (std::ostream &os) const
+{
+  os << "NetlinkMessageHeader "
+    << "len: " << m_nlmsgLen << " "
+    << "flags: " << m_nlmsgFlags << " "
+    << "type: " << m_nlmsgType << " "
+    << "seq: " << m_nlmsgSeq << " "
+    << "pid: " << m_nlmsgPid;
+}
+
+uint32_t 
+NetlinkMessageHeader::GetSerializedSize (void) const
+{
+  /* this is the size of an nlmsghdr payload. */
+  return NETLINK_MSG_HEADER_SIZE;
+}
+
+void
+NetlinkMessageHeader::Serialize (Buffer::Iterator& start) const
+{
+  start.WriteU32 (m_nlmsgLen);
+  start.WriteU16 (m_nlmsgType);
+  start.WriteU16 (m_nlmsgFlags);
+  start.WriteU32 (m_nlmsgSeq);
+  start.WriteU32 (m_nlmsgPid);
+}
+
+uint32_t
+NetlinkMessageHeader::Deserialize (Buffer::Iterator& start)
+{
+  m_nlmsgLen = start.ReadU32 ();
+  m_nlmsgType = start.ReadU16 ();
+  m_nlmsgFlags = start.ReadU16 ();
+  m_nlmsgSeq = start.ReadU32 ();
+  m_nlmsgPid = start.ReadU32 ();
+
+  return GetSerializedSize ();
+}
+
+
+
+
+/***********************************************************************************
+* \ NetlinkMessageError
+***********************************************************************************/
+
+NetlinkMessageError::NetlinkMessageError ()
+: m_error (0)
+{
+}
+NetlinkMessageError::~NetlinkMessageError()
+{}
+void 
+NetlinkMessageError::SetError (int32_t v)
+{
+  m_error = v;
+}
+int32_t
+NetlinkMessageError::GetError (void) const
+{
+  return m_error;
+}
+void
+NetlinkMessageError::SetMsg (NetlinkMessageHeader v)
+{
+  m_msg = v;
+}
+NetlinkMessageHeader
+NetlinkMessageError::GetMsg (void) const
+{
+  return m_msg;
+}
+
+TypeId 
+NetlinkMessageError::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::NetlinkMessageError")
+    .SetParent<NetlinkPayload> ()
+    .AddConstructor<NetlinkMessageError> ()
+    ;
+  return tid;
+}
+
+TypeId 
+NetlinkMessageError::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+void 
+NetlinkMessageError::Print (std::ostream &os) const
+{  
+  os << "----NetlinkMessageError "
+    << "error: " << m_error << " "
+    << "msg:( ";
+  m_msg.Print(os);
+  os << " )";
+}
+
+uint32_t 
+NetlinkMessageError::GetSerializedSize (void) const
+{
+    /* this is the size of an nlmsgerr payload. */
+    return NETLINK_MSG_ERROR_SIZE;
+}
+
+void
+NetlinkMessageError::Serialize (Buffer::Iterator& start) const
+{
+  start.WriteU32 (m_error);
+  m_msg.Serialize (start);
+}
+
+uint32_t
+NetlinkMessageError::Deserialize (Buffer::Iterator& start)
+{  
+  m_error = start.ReadU32 ();
+  m_msg.Deserialize (start);
+  
+  return GetSerializedSize ();
+}
+
+
+
+
+/***********************************************************************************
+* \ NetlinkMessage
+***********************************************************************************/
+NetlinkMessage::NetlinkMessage ()
+{}
+
+void
+NetlinkMessage::SetHeader (NetlinkMessageHeader hdr)
+{
+  m_hdr = hdr;
+}
+NetlinkMessageHeader
+NetlinkMessage::GetHeader(void)const
+{
+  return m_hdr;
+}
+void
+NetlinkMessage::SetGeneralMessage (GeneralMessage genmsg)
+{
+  m_genmsg = genmsg;
+  m_hdr.SetMsgLen (m_hdr.GetSerializedSize () + genmsg.GetSerializedSize ());
+}
+void
+NetlinkMessage::SetErrorMessage(NetlinkMessageError errmsg)
+{
+  m_errorMessage = errmsg;
+  m_hdr.SetMsgLen(m_hdr.GetSerializedSize() + errmsg.GetSerializedSize());
+}
+// the type is one of RTM_NEWLINK,RTM_DELLINK,RTM_GETLINK
+void
+NetlinkMessage::SetInterfaceInfoMessage (InterfaceInfoMessage v)
+{
+  m_hdr.SetMsgLen (m_hdr.GetSerializedSize () + v.GetSerializedSize ());
+  m_interfaceTemplate = v;
+}
+// the type is one of RTM_NEWADDR,RTM_DELADDR,RTM_GETADDR
+void NetlinkMessage::SetInterfaceAddressMessage (InterfaceAddressMessage v)
+{
+  m_hdr.SetMsgLen (m_hdr.GetSerializedSize () + v.GetSerializedSize ());
+  m_addressTemplate = v;
+}
+// the type  is one of RTM_NEWROUTE,RTM_DELROUTE,RTM_GETROUTE
+void NetlinkMessage::SetRouteMessage (RouteMessage v)
+{
+  m_hdr.SetMsgLen (m_hdr.GetSerializedSize () + v.GetSerializedSize ());
+  m_routeTemplate = v;
+}
+GeneralMessage
+NetlinkMessage::GetGeneralMessage (void) const
+{
+  return m_genmsg;
+}
+NetlinkMessageError
+NetlinkMessage::GetErrorMessage (void) const
+{
+  return m_errorMessage;
+}
+InterfaceInfoMessage
+NetlinkMessage::GetInterfaceInfoMessage (void) const
+{
+  return m_interfaceTemplate;
+}
+InterfaceAddressMessage
+NetlinkMessage::GetInterfaceAddressMessage (void) const
+{
+  return m_addressTemplate;
+}
+RouteMessage
+NetlinkMessage::GetRouteMessage (void) const
+{
+  return m_routeTemplate;
+}
+bool
+NetlinkMessage::IsMessageNetlinkControl (uint16_t type)
+{
+  return (type < NETLINK_RTM_BASE);
+}
+bool
+NetlinkMessage::IsMessageNetlinkRoute (uint16_t type)
+{
+  return (type >= NETLINK_RTM_BASE && type < NETLINK_RTM_MAX);
+}
+bool
+NetlinkMessage::IsMessageAddress (uint16_t type)
+{
+  return (type >= NETLINK_RTM_NEWADDR && type <= NETLINK_RTM_GETADDR);
+}
+bool
+NetlinkMessage::IsMessageInterface (uint16_t type)
+{
+  return (type >= NETLINK_RTM_NEWLINK && type <= NETLINK_RTM_SETLINK);
+}
+bool
+NetlinkMessage::IsMessageRoute (uint16_t type)
+{
+  return (type >= NETLINK_RTM_NEWROUTE && type <= NETLINK_RTM_GETROUTE);
+}
+bool
+NetlinkMessage::IsMessageTypeGet (uint16_t type)
+{
+  return ((( type - NETLINK_RTM_BASE)&3) == 2);
+}
+bool
+NetlinkMessage::IsMessageFlagsAck (uint16_t flags)
+{
+  return (flags & NETLINK_MSG_F_ACK) ? true : false;
+}
+bool
+NetlinkMessage::IsMessageFlagsRequest (uint16_t flags)
+{
+  return (flags & NETLINK_MSG_F_REQUEST) ? true : false;
+}
+bool
+NetlinkMessage::IsMessageFlagsDump (uint16_t flags)
+{
+  return (flags & NETLINK_MSG_F_DUMP) ? true : false;
+}
+
+NetlinkMessage::operator MultipartNetlinkMessage (void) const
+{
+  MultipartNetlinkMessage multi_nlmsg;
+  multi_nlmsg.AppendMessage(*this);
+  return multi_nlmsg;
+}
+
+TypeId 
+NetlinkMessage::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::NetlinkMessage")
+    .SetParent<Header> ()
+    .AddConstructor<NetlinkMessage> ()
+    ;
+  return tid;
+}
+TypeId 
+NetlinkMessage::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+
+uint32_t
+NetlinkMessage::GetTotalSize (void) const
+{
+  return NETLINK_MSG_ALIGN(m_hdr.GetMsgLen ());
+}
+
+uint32_t
+NetlinkMessage::GetMsgSize (void) const
+{
+  return m_hdr.GetMsgLen ();
+}
+
+uint32_t
+NetlinkMessage::GetPayloadSize (void) const
+{
+  return m_hdr.GetPayloadSize ();
+}
+uint16_t
+NetlinkMessage::GetMsgType (void) const
+{
+  return m_hdr.GetMsgType ();
+}
+
+uint8_t
+NetlinkMessage::GetFamily(void) const
+{
+  if (IsMessageFlagsDump(m_hdr.GetMsgFlags()))
+    {
+      return m_genmsg.GetFamily();
+    }
+  else if (IsMessageAddress(m_hdr.GetMsgType()))
+    {
+      return m_addressTemplate.GetFamily();
+    }
+  else if (IsMessageInterface(m_hdr.GetMsgType()))
+    {
+      return m_interfaceTemplate.GetFamily();
+    }
+  else if (IsMessageRoute(m_hdr.GetMsgType()))
+    {
+      return m_routeTemplate.GetFamily();
+    }
+  else
+    {
+      NS_LOG_WARN("Netlink message type not supported, return AF_UNSPEC");
+      return 0;
+    }
+}
+
+void 
+NetlinkMessage::Print (std::ostream &os) const
+{
+  uint16_t type = m_hdr.GetMsgType ();
+
+  os << "NetlinkMessage  ";
+  os << " ----Header:(";
+  m_hdr.Print(os);
+  os << ")";
+
+  if (type == NETLINK_MSG_DONE )
+    {
+      os << "multipart message ends here";
+    }
+  else if (type == NETLINK_MSG_ERROR )
+    {
+      m_errorMessage.Print(os);
+    }
+  else if (type == NETLINK_RTM_GETROUTE || type == NETLINK_RTM_GETADDR || type == NETLINK_RTM_GETLINK)
+    {
+      m_genmsg.Print(os);
+    }  
+  else if (type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE)
+    {
+      m_routeTemplate.Print(os);
+    }
+  else if (type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR)
+    {
+      m_addressTemplate.Print(os);
+    }
+  else if (type == NETLINK_RTM_NEWLINK || type == NETLINK_RTM_DELLINK)
+    {
+      m_interfaceTemplate.Print(os);
+    }
+  else
+    {
+      os << "service not supported yet( " << type <<")";
+    }
+}
+uint32_t 
+NetlinkMessage::GetSerializedSize (void) const
+{
+  return NETLINK_MSG_ALIGN(m_hdr.GetMsgLen ());
+}
+
+void
+NetlinkMessage::Serialize (Buffer::Iterator& start) const
+{
+  uint16_t type = m_hdr.GetMsgType();
+
+  m_hdr.Serialize (start);
+
+  if (type == NETLINK_MSG_DONE)
+    {
+      //nothing done
+    }
+  else if (type == NETLINK_MSG_ERROR)
+    {
+      m_errorMessage.Serialize(start);
+    }  
+  else if (NetlinkMessage::IsMessageFlagsDump(m_hdr.GetMsgFlags()) && (type == NETLINK_RTM_GETROUTE
+    || type == NETLINK_RTM_GETADDR || type == NETLINK_RTM_GETLINK))
+    {
+      m_genmsg.Serialize (start);
+    }  
+  else if (type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE || type == NETLINK_RTM_GETROUTE)
+    {
+      m_routeTemplate.Serialize (start);
+    }
+  else if (type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR)
+    {
+      m_addressTemplate.Serialize (start);
+    }
+  else if (type == NETLINK_RTM_NEWLINK || type == NETLINK_RTM_SETLINK)
+    {
+      m_interfaceTemplate.Serialize (start);
+    }
+  else
+    {
+    }  
+}
+
+
+uint32_t
+NetlinkMessage::Deserialize (Buffer::Iterator&start)
+{
+  uint32_t remaining;
+
+  m_hdr.Deserialize (start);
+  remaining = NETLINK_MSG_ALIGN(m_hdr.GetMsgLen ()) - m_hdr.GetSerializedSize ();
+  
+  //Deserialize service module
+  uint16_t type = GetMsgType ();
+  if (remaining)
+    {        
+      if (type == NETLINK_MSG_DONE)
+        {
+          //do nothing
+        }
+      else if (type == NETLINK_MSG_ERROR)
+        {
+          remaining -= m_errorMessage.Deserialize(start);
+        }      
+      else if (NetlinkMessage::IsMessageFlagsDump(m_hdr.GetMsgFlags()) && (type == NETLINK_RTM_GETROUTE
+        || type == NETLINK_RTM_GETADDR || type == NETLINK_RTM_GETLINK))
+        {
+          remaining -= m_genmsg.Deserialize (start, remaining);
+        }
+      else if (type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE || type == NETLINK_RTM_GETROUTE)
+        {
+          remaining -= m_routeTemplate.Deserialize (start, remaining);
+        }
+      else if (type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR)
+        {
+          remaining -= m_addressTemplate.Deserialize (start, remaining);
+        }
+      else if (type == NETLINK_RTM_NEWLINK || type == NETLINK_RTM_SETLINK)
+        {
+          remaining -= m_interfaceTemplate.Deserialize (start, remaining);
+        }
+      else
+        {
+          //do nothing
+        }
+    }
+
+  return GetSerializedSize ();
+}
+
+
+/***********************************************************************************
+* \ MultipartNetlinkMessage
+***********************************************************************************/
+MultipartNetlinkMessage::MultipartNetlinkMessage()
+{}
+
+TypeId 
+MultipartNetlinkMessage::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::MultipartNetlinkMessage")
+    .SetParent<Header> ()
+    .AddConstructor<MultipartNetlinkMessage> ()
+    ;
+  return tid;
+}
+TypeId 
+MultipartNetlinkMessage::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+
+void
+MultipartNetlinkMessage::Print (std::ostream &os) const
+{
+  for (uint32_t i = 0; i <  m_netlinkMessages.size (); i ++)
+    {
+      m_netlinkMessages[i].Print(os);
+    }
+}
+uint32_t
+MultipartNetlinkMessage::GetSerializedSize (void) const
+{
+  uint32_t len = 0;
+
+  for (uint32_t i = 0; i <  m_netlinkMessages.size (); i ++)
+    {
+      len +=  m_netlinkMessages[i].GetSerializedSize ();
+    }
+  return len;
+}
+void
+MultipartNetlinkMessage::Serialize (Buffer::Iterator start) const
+{
+  for (uint32_t i = 0; i <  m_netlinkMessages.size (); i ++)
+    {
+      m_netlinkMessages[i].Serialize(start);
+    }
+}
+uint32_t
+MultipartNetlinkMessage::Deserialize (Buffer::Iterator start)
+{
+  while (1)
+    {
+      NetlinkMessage nlmsg;
+      nlmsg.Deserialize (start);
+      AppendMessage(nlmsg);
+
+      if (!(nlmsg.GetHeader().GetMsgFlags()&NETLINK_MSG_F_MULTI))
+        break;
+
+      if (nlmsg.GetHeader().GetMsgType() == NETLINK_MSG_DONE)
+        break;
+    }
+  return GetSerializedSize ();
+}
+
+void
+MultipartNetlinkMessage::AppendMessage (NetlinkMessage nlmsg)
+{
+  m_netlinkMessages.push_back(nlmsg);
+}
+
+void
+MultipartNetlinkMessage::Clear()
+{
+  m_netlinkMessages.clear();
+}
+
+uint32_t
+MultipartNetlinkMessage::GetNMessages (void) const
+{
+  return m_netlinkMessages.size();
+}
+NetlinkMessage
+MultipartNetlinkMessage::GetMessage(uint32_t index) const
+{
+  NS_ASSERT(index < m_netlinkMessages.size());
+  return m_netlinkMessages[index];
+}
+}; // namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-message.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,255 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#ifndef NETLINK_MESSAGE_H
+#define NETLINK_MESSAGE_H
+
+#include "ns3/header.h"
+#include "ns3/address.h"
+#include "ns3/netlink-message-route.h"
+#include "ns3/netlink-attribute.h"
+
+
+namespace ns3 {
+  class NetlinkPayload;
+  class GeneralMessage;
+  class InterfaceAddressMessage;
+  class InterfaceInfoMessage;
+  class RouteMessage;
+  class MultipartNetlinkMessage;
+
+/**
+* \brief The Netlink message structure for an netlink packet
+* 
+There are three levels to a Netlink message: The general Netlink
+message header, the IP service specific template, and the IP service
+specific data.
+
+0                   1                   2                   3
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                                               |
+|                   Netlink message header                      |
+|                                                               |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                                               |
+|                  IP Service Template                          |
+|                                                               |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+|                                                               |
+|                  IP Service specific data in TLVs             |
+|                                                               |
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+*/
+
+  enum NetlinkMessageFlag
+  {
+    NETLINK_MSG_F_REQUEST = 1,	/* It is request message. 	*/
+    NETLINK_MSG_F_MULTI = 2,	/* Multipart message, terminated by NETLINK_MSG_DONE */
+    NETLINK_MSG_F_ACK = 4,	/* Reply with ack, with zero or error code */
+    NETLINK_MSG_F_ECHO = 8,	/* Echo this request  = */
+
+    /* Modifiers to Get request */
+    NETLINK_MSG_F_ROOT = 0x100,	/* specify tree	root	*/
+    NETLINK_MSG_F_MATCH =	0x200,	/* return all matching	*/
+    NETLINK_MSG_F_ATOMIC = 0x400,	/* atomic Get = */
+    NETLINK_MSG_F_DUMP = (NETLINK_MSG_F_ROOT|NETLINK_MSG_F_MATCH),
+
+    /* Modifiers to NEW request */
+    NETLINK_MSG_F_REPLACE =	0x100,	/* Override existing = */
+    NETLINK_MSG_F_EXCL	= 0x200,	/* Do not touch, if it exists	*/
+    NETLINK_MSG_F_CREATE = 0x400,	/* Create, if it does not exist	*/
+    NETLINK_MSG_F_APPEND = 0x800,	/* Add to end of list = */ 	
+  };
+
+  enum NetlinkMessageType
+  {
+    NETLINK_MSG_NOOP	=	0x1,	/* Nothing.		*/
+    NETLINK_MSG_ERROR	=	0x2,	/* Error		*/
+    NETLINK_MSG_DONE	=	0x3,	/* End of a dump	*/
+    NETLINK_MSG_OVERRUN	=	0x4,	/* Data lost		*/
+    NETLINK_MSG_MIN_TYPE	=	0x10,	/* < 0x10: reserved control messages */
+  };
+
+#define NETLINK_MSG_ALIGNTO	4
+#define NETLINK_MSG_ALIGN(len)    ( ((len)+NETLINK_MSG_ALIGNTO-1) & ~(NETLINK_MSG_ALIGNTO-1) )
+
+class NetlinkMessageHeader : public ObjectBase
+{
+public:
+  NetlinkMessageHeader ();
+  NetlinkMessageHeader (uint16_t type, uint16_t flags, uint32_t seq, uint32_t pid);
+
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const;
+  void Print (std::ostream &os) const;
+  uint32_t GetSerializedSize (void) const;
+  void Serialize (Buffer::Iterator& start) const;
+  uint32_t Deserialize (Buffer::Iterator& start);
+
+  void SetMsgLen (uint32_t v);
+  void SetMsgFlags (uint16_t v);
+  void SetMsgType (uint16_t v);
+  void SetMsgSeq (uint32_t v);
+  void SetMsgPid (uint32_t v);
+  uint32_t GetMsgLen (void) const;
+  uint16_t GetMsgFlags (void) const;
+  uint16_t GetMsgType (void) const;
+  uint32_t GetMsgSeq (void) const;
+  uint32_t GetMsgPid (void) const;
+
+  static uint32_t GetHeaderSize ();
+  uint32_t GetPayloadSize (void) const;
+
+private:
+  static const uint32_t NETLINK_MSG_HEADER_SIZE = 16; /* size of the nlmsghdr field*/
+  uint32_t m_nlmsgLen;	/* Length of message including header */
+  uint16_t m_nlmsgType;	/* Message content */
+  uint16_t m_nlmsgFlags;	/* Additional flags */
+  uint32_t m_nlmsgSeq;	/* Sequence number */
+  uint32_t m_nlmsgPid;	/* Sending process PID */
+};
+
+/**
+* \brief The struct nlmsgerr
+*/
+class NetlinkMessageError : public NetlinkPayload
+{
+public:
+  NetlinkMessageError ();
+  virtual ~NetlinkMessageError();
+
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const;
+  virtual void Serialize (Buffer::Iterator& start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator& start);
+  virtual void Print (std::ostream &os) const;
+  virtual uint32_t GetSerializedSize (void) const;
+
+  void SetError (int32_t v);
+  int32_t GetError (void) const;
+  void SetMsg(NetlinkMessageHeader v);
+  NetlinkMessageHeader GetMsg (void) const;
+
+private:
+  static const int NETLINK_MSG_ERROR_SIZE = 20; /* size of the nlmsgerror field*/
+  int32_t m_error;
+  NetlinkMessageHeader m_msg;        
+};
+
+
+class NetlinkMessage : public ObjectBase
+{
+public:
+  NetlinkMessage ();
+
+  static TypeId GetTypeId (void);
+  TypeId GetInstanceTypeId (void) const;
+  void Print (std::ostream &os) const;
+  uint32_t GetSerializedSize (void) const;
+  void Serialize (Buffer::Iterator& start) const;
+  uint32_t Deserialize (Buffer::Iterator& start);
+
+  operator MultipartNetlinkMessage (void) const;
+
+  uint32_t GetTotalSize (void) const;  //length of netlink message including padding
+  uint32_t GetMsgSize (void) const;    //length of netlink message not including padding
+  uint32_t GetPayloadSize (void) const; //length of message payload
+  uint16_t GetMsgType (void) const;
+  uint8_t GetFamily(void) const;
+
+  void SetHeader (NetlinkMessageHeader hdr);
+  NetlinkMessageHeader GetHeader (void) const;
+
+  //before set message body, should set header first
+  void SetErrorMessage (NetlinkMessageError errmsg);
+  void SetGeneralMessage (GeneralMessage genmsg);
+  void SetInterfaceInfoMessage (InterfaceInfoMessage v);
+  void SetInterfaceAddressMessage (InterfaceAddressMessage v);
+  void SetRouteMessage (RouteMessage v);
+  NetlinkMessageError GetErrorMessage (void) const;
+  GeneralMessage GetGeneralMessage (void) const;
+  InterfaceInfoMessage GetInterfaceInfoMessage (void) const;
+  InterfaceAddressMessage GetInterfaceAddressMessage (void) const;
+  RouteMessage GetRouteMessage (void) const;
+
+  /**
+  * \returns true if type was control type, false otherwise.
+  */
+  static bool IsMessageNetlinkControl (uint16_t type);
+  /**
+  * \returns true if type was netlink route, false otherwise.
+  */
+  static bool IsMessageNetlinkRoute (uint16_t type);
+  static bool IsMessageAddress (uint16_t type);
+  static bool IsMessageInterface (uint16_t type);
+  static bool IsMessageRoute (uint16_t type);
+  /**
+  * \returns true if type was GETxxx , false otherwise.
+  */
+  static bool IsMessageTypeGet (uint16_t type);
+  /**
+  * \returns true if flag has ack , false otherwise.
+  */
+  static bool IsMessageFlagsAck (uint16_t flags);
+  /**
+  * \returns true if flag has request , false otherwise.
+  */
+  static bool IsMessageFlagsRequest (uint16_t flags);
+  /**
+  * \returns true if flag has dump , false otherwise.
+  */
+  static bool IsMessageFlagsDump (uint16_t flags);
+
+private:
+  NetlinkMessageHeader m_hdr;
+
+  //only one type of messages below exists in real world application
+  NetlinkMessageError m_errorMessage;  
+  GeneralMessage m_genmsg;
+  InterfaceInfoMessage m_interfaceTemplate;
+  InterfaceAddressMessage m_addressTemplate;
+  RouteMessage m_routeTemplate;
+};
+
+class MultipartNetlinkMessage : public Header
+{
+public:
+  MultipartNetlinkMessage ();
+
+  static TypeId GetTypeId (void);
+  virtual TypeId GetInstanceTypeId (void) const;
+  virtual void Print (std::ostream &os) const;
+  virtual uint32_t GetSerializedSize (void) const;
+  virtual void Serialize (Buffer::Iterator start) const;
+  virtual uint32_t Deserialize (Buffer::Iterator start);
+
+  void AppendMessage (NetlinkMessage nlmsg);
+  void Clear();
+  uint32_t GetNMessages (void) const;
+  NetlinkMessage GetMessage(uint32_t index) const;
+
+private:
+  std::vector<NetlinkMessage> m_netlinkMessages;
+};
+
+}; // namespace ns3
+
+#endif /* NETLINK_MESSAGE_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-socket-address.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,118 @@
+/* -*-	Mode:C; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#include "netlink-socket-address.h"
+
+namespace ns3 {
+
+NetlinkSocketAddress::NetlinkSocketAddress(uint32_t pid, uint32_t groups)
+  :m_pid(pid), m_groups(groups)
+{}
+
+NetlinkSocketAddress::NetlinkSocketAddress ()
+    :m_pid (0),m_groups (0)
+{}
+
+NetlinkSocketAddress::~NetlinkSocketAddress ()
+{}
+
+void NetlinkSocketAddress::SetProcessID (uint32_t pid)
+{
+    m_pid = pid;
+}
+
+void NetlinkSocketAddress::SetGroupsMask (uint32_t mask)
+{
+    m_groups = mask;
+}
+
+uint32_t NetlinkSocketAddress::GetProcessID (void) const
+{
+    return m_pid;
+}
+
+uint32_t NetlinkSocketAddress::GetGroupsMask (void) const
+{
+    return m_groups;
+}
+
+NetlinkSocketAddress::operator Address (void) const
+{
+    return ConvertTo ();
+}
+
+Address NetlinkSocketAddress::ConvertTo (void) const
+{
+    uint8_t buffer[8];
+
+    buffer[0] = (m_pid >> 24) & 0xff;
+    buffer[1] = (m_pid >> 16) & 0xff;
+    buffer[2] = (m_pid >> 8) & 0xff;
+    buffer[3] = (m_pid >> 0) & 0xff;
+    buffer[4] = (m_groups >> 24) & 0xff;
+    buffer[5] = (m_groups >> 16) & 0xff;
+    buffer[6] = (m_groups >> 8) & 0xff;
+    buffer[7] = (m_groups >> 0) & 0xff;
+
+    return Address (GetType (), buffer, 8);
+}
+
+NetlinkSocketAddress NetlinkSocketAddress::ConvertFrom (const Address &address)
+{
+    NS_ASSERT (IsMatchingType (address));
+
+    NetlinkSocketAddress nl;
+    uint8_t buf[8];
+
+    address.CopyTo (buf);
+
+    nl.m_pid = 0;
+    nl.m_pid |= buf[0];
+    nl.m_pid <<= 8;
+    nl.m_pid |= buf[1];
+    nl.m_pid <<= 8;
+    nl.m_pid |= buf[2];
+    nl.m_pid <<= 8;
+    nl.m_pid |= buf[3];
+
+    nl.m_groups = 0;
+    nl.m_groups |= buf[4];
+    nl.m_groups <<= 8;
+    nl.m_groups |= buf[5];
+    nl.m_groups <<= 8;
+    nl.m_groups |= buf[6];
+    nl.m_groups <<= 8;
+    nl.m_groups |= buf[7];
+
+    return nl;
+}
+
+bool NetlinkSocketAddress::IsMatchingType (const Address &address)
+{
+    return address.IsMatchingType (GetType ());
+}
+
+uint8_t NetlinkSocketAddress::GetType (void)
+{
+    static uint8_t type = Address::Register ();
+    return type;
+}
+
+} // namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-socket-address.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,69 @@
+/* -*-	Mode:C; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+#ifndef NETLINK_SOCKET_ADDRESS_H
+#define NETLINK_SOCKET_ADDRESS_H
+
+#include "ns3/ptr.h"
+#include "address.h"
+
+namespace ns3 {
+
+class NetlinkSocketAddress
+{
+public:
+  NetlinkSocketAddress (uint32_t pid, uint32_t groups);
+  NetlinkSocketAddress ();
+  ~NetlinkSocketAddress ();
+
+  void SetProcessID (uint32_t pid);
+  void SetGroupsMask (uint32_t mask);
+
+  uint32_t GetProcessID (void) const;
+  uint32_t GetGroupsMask (void) const;
+
+  /**
+  * \returns an Address instance which represents this
+  * NetlinkSocketAddress instance.
+  */
+  operator Address (void) const;
+  /**
+  * \param address the Address instance to convert from.
+  *
+  * Returns an NetlinkSocketAddress which corresponds to the input
+  * Address
+  */
+  static NetlinkSocketAddress ConvertFrom (const Address &address);
+  /**
+  * \returns true if the address matches, false otherwise.
+  */
+  static bool IsMatchingType (const Address &address);
+private:
+  static uint8_t GetType (void);
+  Address ConvertTo (void) const;
+
+  uint32_t m_pid;
+  uint32_t m_groups;
+
+};
+
+
+} // namespace ns3
+
+#endif /* NETLINK_SOCKET_ADDRESS_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-socket-factory.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,47 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#include "netlink-socket-factory.h"
+#include "node.h"
+#include "netlink-socket.h"
+
+namespace ns3 {
+
+NS_OBJECT_ENSURE_REGISTERED (NetlinkSocketFactory);
+
+TypeId 
+NetlinkSocketFactory::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::NetlinkSocketFactory")
+    .SetParent<SocketFactory> ();
+  return tid;
+}
+
+NetlinkSocketFactory::NetlinkSocketFactory ()
+{}
+
+Ptr<Socket> NetlinkSocketFactory::CreateSocket (void)
+{
+  Ptr<Node> node = GetObject<Node> ();
+  Ptr<NetlinkSocket> socket = CreateObject<NetlinkSocket> ();
+  socket->SetNode (node);
+  return socket;
+} 
+} // namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-socket-factory.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,50 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2008 Liu Jian
+ *
+ * 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: Liu Jian <liujatp@gmail.com>
+ */
+#ifndef NETLINK_SOCKET_FACTORY_H
+#define NETLINK_SOCKET_FACTORY_H
+
+#include "socket-factory.h"
+
+namespace ns3 {
+
+class Socket;
+
+/**
+ * This can be used as an interface in a node in order for the node to
+ * generate NetlinkSockets.
+ */
+class NetlinkSocketFactory : public SocketFactory
+{
+public:
+  static TypeId GetTypeId (void);
+
+  NetlinkSocketFactory ();
+
+  /**
+   * Creates a NetlinkSocket and returns a pointer to it.
+   *
+   * \return a pointer to the created socket
+   */
+  virtual Ptr<Socket> CreateSocket (void);
+};
+
+} // namespace ns3
+
+#endif /* NETLINK_SOCKET_FACTORY_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-socket-test.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,555 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+#ifdef RUN_SELF_TESTS
+
+#include "ns3/test.h"
+#include "ns3/core-module.h"
+#include "ns3/simulator-module.h"
+#include "ns3/node-module.h"
+#include "ns3/helper-module.h"
+#include "ns3/global-route-manager.h"
+#include "ns3/assert.h"
+#include "ns3/log.h"
+#include <string>
+#include <list>
+
+
+NS_LOG_COMPONENT_DEFINE ("NetlinkSocketTest");
+
+using namespace ns3;
+
+
+class NetlinkSocketTest: public Test 
+{
+public:
+  NetlinkSocketTest ();
+  virtual bool RunTests (void);
+private:
+  NetlinkMessage BuildGetMessage (uint16_t type, uint16_t flags);
+  NetlinkMessage BuildAddressMessage (uint16_t type, uint16_t flags);
+  NetlinkMessage BuildLinkChangeMessage (uint16_t type, uint16_t flags);
+  NetlinkMessage BuildRouteMessage (uint16_t type, uint16_t flags);
+  MultipartNetlinkMessage BuildMultipartMessage (uint16_t type, uint16_t flags);
+
+  bool CheckIsAck (NetlinkMessage nlmsg);
+  bool CheckIsDump (MultipartNetlinkMessage nlmsg);
+  bool CheckIsEqual (NetlinkMessageHeader nhr1, NetlinkMessageHeader nhr2);
+  bool CheckIsEqual (NetlinkMessage nlmsg1, NetlinkMessage nlmsg2);
+  bool CheckIsEqual (MultipartNetlinkMessage mulmsg1, MultipartNetlinkMessage mulmsg2);
+
+  bool TestNetlinkSerilization ();
+  bool TestInterfaceAddressMessage ();
+  bool TestInferfaceInfoMessage ();
+  bool TestRouteMessage ();
+  bool TestBroadcastMessage ();
+
+  void ReceiveUnicastPacket (Ptr<Socket> socket);
+  void ReceiveMulticastPacket (Ptr<Socket> socket);
+  void SendCmdToKernel (uint16_t type);
+  void SendNetlinkMessage (NetlinkMessage nlmsg);
+  void MonitorKernelChanges ();
+
+  std::list<MultipartNetlinkMessage> m_unicastList;
+  std::list<MultipartNetlinkMessage> m_multicastList;
+  Ptr<Socket> m_cmdSock;
+  Ptr<Socket> m_groupSock;  
+  int m_pid;
+};
+
+
+
+NetlinkMessage
+NetlinkSocketTest::BuildGetMessage(uint16_t type, uint16_t flags)
+{
+  NS_ASSERT(type == NETLINK_RTM_GETLINK || type == NETLINK_RTM_GETADDR || type == NETLINK_RTM_GETROUTE);
+
+  NetlinkMessage nlmsg;
+  flags |= (NETLINK_MSG_F_DUMP|NETLINK_MSG_F_ACK|NETLINK_MSG_F_REQUEST);
+  nlmsg.SetHeader(NetlinkMessageHeader(type, flags, 0, 0));
+  GeneralMessage genmsg;
+  genmsg.SetFamily(2);
+  nlmsg.SetGeneralMessage(genmsg);
+  //no attributes appended
+  return nlmsg;
+}
+
+NetlinkMessage
+NetlinkSocketTest::BuildAddressMessage( uint16_t type, uint16_t flags)
+{
+  NS_ASSERT(type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR);
+
+  flags |= (NETLINK_MSG_F_ACK|NETLINK_MSG_F_REQUEST); 
+  if (type == NETLINK_RTM_NEWADDR)
+      {
+        flags |= NETLINK_MSG_F_CREATE;
+      }
+
+  NetlinkMessage nlmsg;
+  //set header
+  nlmsg.SetHeader(NetlinkMessageHeader(type, flags, 0, 0));
+
+  //set service module
+  InterfaceAddressMessage ifamsg;
+  {    
+    ifamsg.SetFamily(2);
+    ifamsg.SetLength(24);
+    ifamsg.SetInterfaceIndex(3);
+
+    ifamsg.AppendAttribute(NetlinkAttribute(InterfaceAddressMessage::IF_A_LOCAL, ADDRESS, Ipv4Address("192.168.0.1")));
+    ifamsg.AppendAttribute(NetlinkAttribute(InterfaceAddressMessage::IF_A_ADDRESS,ADDRESS, Ipv4Address("192.168.0.2")));
+    ifamsg.AppendAttribute(NetlinkAttribute(InterfaceAddressMessage::IF_A_LABEL, STRING, "TESTSTRING"));
+  }
+
+  nlmsg.SetInterfaceAddressMessage(ifamsg);
+
+  return nlmsg;
+}
+
+NetlinkMessage
+NetlinkSocketTest::BuildLinkChangeMessage( uint16_t type, uint16_t flags)
+{
+  NetlinkMessage nlmsg;
+  NS_LOG_WARN(this<<type<<flags<< " not supported");
+  return nlmsg;
+}
+
+NetlinkMessage
+NetlinkSocketTest::BuildRouteMessage(uint16_t type, uint16_t flags)
+{
+  NS_ASSERT(type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE);
+
+  flags |= (NETLINK_MSG_F_ACK|NETLINK_MSG_F_REQUEST); 
+  if (type == NETLINK_RTM_NEWROUTE)
+    {
+      flags |= NETLINK_MSG_F_CREATE;
+    }
+
+  NetlinkMessage nlmsg;
+  //set header
+  nlmsg.SetHeader(NetlinkMessageHeader(type, flags, 0, m_pid));
+
+  //set service module
+  RouteMessage rtmsg;
+  //set attribute
+  {
+    rtmsg.AppendAttribute(NetlinkAttribute(RouteMessage::RT_A_DST, ADDRESS, Ipv4Address("192.168.0.10")));
+    rtmsg.AppendAttribute(NetlinkAttribute(RouteMessage::RT_A_SRC, ADDRESS, Ipv4Address("192.168.2.10")));
+    rtmsg.AppendAttribute(NetlinkAttribute(RouteMessage::RT_A_GATEWAY, ADDRESS, Ipv4Address("192.168.2.1")));
+    rtmsg.AppendAttribute(NetlinkAttribute(RouteMessage::RT_A_OIF, U32, (uint32_t)2));
+  }
+
+  nlmsg.SetRouteMessage(rtmsg);
+  return nlmsg;
+}
+
+MultipartNetlinkMessage
+NetlinkSocketTest::BuildMultipartMessage(uint16_t type, uint16_t flags)
+{
+  //usually multi-part message used for message dump, kernel return to user space for NETLINK_RTM_GETxxx
+  //type = NETLINK_RTM_NEWxxx, flags = NETLINK_MSG_F_MULTI, terminated by NETLINK_MSG_DONE, 
+  //here this example contain 2 NETLINK_MSG_F_MULTI
+  NS_ASSERT(flags&NETLINK_MSG_F_MULTI);
+
+  MultipartNetlinkMessage nlmsg;
+  NetlinkMessage nlmsg1, nlmsg2, nlmsg3;
+  nlmsg1 = BuildAddressMessage(NETLINK_RTM_NEWADDR, NETLINK_MSG_F_MULTI);
+  nlmsg.AppendMessage(nlmsg1);
+  //the first nlmsg
+  nlmsg2 = BuildRouteMessage(NETLINK_RTM_NEWROUTE, NETLINK_MSG_F_MULTI);
+  nlmsg.AppendMessage(nlmsg2);
+  //the second nlmsg
+  nlmsg3.SetHeader(NetlinkMessageHeader(NETLINK_MSG_DONE, flags, 1, m_pid));
+  nlmsg.AppendMessage(nlmsg3);
+
+  return nlmsg;
+}
+
+
+
+
+bool
+NetlinkSocketTest::CheckIsAck(NetlinkMessage nlmsg)
+{
+  return (nlmsg.GetMsgType() == NETLINK_MSG_ERROR && nlmsg.GetErrorMessage().GetError() == 0);
+}
+
+bool
+NetlinkSocketTest::CheckIsDump(MultipartNetlinkMessage mulmsg)
+{
+  return ( mulmsg.GetNMessages() > 0 && mulmsg.GetMessage(0).GetHeader().GetMsgFlags() & NETLINK_MSG_F_MULTI &&
+    mulmsg.GetMessage(mulmsg.GetNMessages()-1).GetMsgType() == NETLINK_MSG_DONE); 
+}
+
+bool
+NetlinkSocketTest::CheckIsEqual(NetlinkMessageHeader nhr1, NetlinkMessageHeader nhr2)
+{
+  return (nhr1.GetMsgType() == nhr2.GetMsgType() && nhr1.GetMsgFlags() == nhr2.GetMsgFlags() && nhr1.GetMsgLen() == nhr2.GetMsgLen());
+}
+
+bool
+NetlinkSocketTest::CheckIsEqual(NetlinkMessage nlmsg1, NetlinkMessage nlmsg2)
+{
+  return CheckIsEqual(nlmsg1.GetHeader(), nlmsg2.GetHeader());
+}
+
+bool
+NetlinkSocketTest::CheckIsEqual(MultipartNetlinkMessage mulmsg1, MultipartNetlinkMessage mulmsg2)
+{
+  if (mulmsg1.GetNMessages() != mulmsg2.GetNMessages())
+    return false;
+
+  for (uint32_t i = 0; i < mulmsg1.GetNMessages(); i ++)
+    {
+      if (!CheckIsEqual(mulmsg1.GetMessage(i), mulmsg2.GetMessage(i)))
+        return false;
+    }
+  return true;  
+}
+
+bool
+NetlinkSocketTest::TestNetlinkSerilization()
+{
+  MultipartNetlinkMessage multinlmsg1, multinlmsg2;
+  Ptr<Packet> p = Create<Packet> ();
+  bool result = true;
+
+  multinlmsg1 = BuildMultipartMessage(NETLINK_RTM_NEWADDR, NETLINK_MSG_F_REQUEST|NETLINK_MSG_F_MULTI);
+  p->AddHeader (multinlmsg1);
+  p->RemoveHeader(multinlmsg2);
+  NS_TEST_ASSERT(CheckIsEqual(multinlmsg1, multinlmsg2));
+
+  return result;
+}
+bool
+NetlinkSocketTest::TestInterfaceAddressMessage()
+{
+  MultipartNetlinkMessage dump1, dump2, dump3;
+  NetlinkMessage nlmsg1,nlmsg2;
+  bool result = true;
+
+  //dump interface address
+  SendNetlinkMessage(BuildGetMessage(NETLINK_RTM_GETADDR, 0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  dump1 = m_unicastList.front();
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsDump(dump1));
+
+  //add interface address
+  SendNetlinkMessage(BuildAddressMessage(NETLINK_RTM_NEWADDR,0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  nlmsg1 = m_unicastList.front().GetMessage(0);
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsAck(nlmsg1));
+
+  //dump interface address
+  SendNetlinkMessage(BuildGetMessage(NETLINK_RTM_GETADDR, 0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  dump2 = m_unicastList.front();
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsDump(dump2));
+
+  //del interface address
+  SendNetlinkMessage(BuildAddressMessage(NETLINK_RTM_DELADDR,0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  nlmsg2 = m_unicastList.front().GetMessage(0);
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsAck(nlmsg2));
+
+  //dump interface address
+  SendNetlinkMessage(BuildGetMessage(NETLINK_RTM_GETADDR, 0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  dump3 = m_unicastList.front();
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsDump(dump3));
+
+  NS_TEST_ASSERT(CheckIsEqual(dump1, dump3));
+
+  return result;
+}
+
+
+bool
+NetlinkSocketTest::TestRouteMessage()
+{
+  MultipartNetlinkMessage dump1, dump2, dump3;
+  NetlinkMessage nlmsg1,nlmsg2;
+  bool result = true;
+
+  //dump route entry
+  SendNetlinkMessage(BuildGetMessage(NETLINK_RTM_GETROUTE, 0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  dump1 = m_unicastList.front();
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsDump(dump1));
+
+  //add route entry
+  SendNetlinkMessage(BuildRouteMessage(NETLINK_RTM_NEWROUTE,0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  nlmsg1 = m_unicastList.front().GetMessage(0);
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsAck(nlmsg1));
+
+  //dump route entry
+  SendNetlinkMessage(BuildGetMessage(NETLINK_RTM_GETROUTE, 0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  dump2 = m_unicastList.front();
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsDump(dump2));
+
+  //del route entry
+  SendNetlinkMessage(BuildRouteMessage(NETLINK_RTM_DELROUTE,0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  nlmsg2 = m_unicastList.front().GetMessage(0);
+  m_unicastList.pop_front();
+  NS_ASSERT(CheckIsAck(nlmsg2));
+
+  //dump route entry
+  SendNetlinkMessage(BuildGetMessage(NETLINK_RTM_GETROUTE, 0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  dump3 = m_unicastList.front();
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsDump(dump3));
+
+  NS_TEST_ASSERT(CheckIsEqual(dump1, dump3));
+
+  return result;
+}
+
+bool
+NetlinkSocketTest::TestInferfaceInfoMessage()
+{
+  //now netlink not support NEWLINK/DELLINK yet
+  MultipartNetlinkMessage multinlmsg;
+  bool result = true;
+
+  //dump interface address
+  SendNetlinkMessage(BuildGetMessage(NETLINK_RTM_GETLINK, 0));
+  NS_TEST_ASSERT_EQUAL(m_unicastList.size(), 1);
+  multinlmsg = m_unicastList.front();
+  m_unicastList.pop_front();
+  NS_TEST_ASSERT(CheckIsDump(multinlmsg));
+
+  NS_TEST_ASSERT(multinlmsg.GetNMessages() > 1 && multinlmsg.GetMessage(0).GetMsgType() == NETLINK_RTM_NEWLINK);
+
+  return result;
+}
+
+bool
+NetlinkSocketTest::TestBroadcastMessage()
+{
+  bool result = true;
+  //at 2Xs, m_cmdSock send an request to kernel to add/del an interface address
+  //and an route entry,  the m_groupSock will recv the changed information
+  //through the broadcast way  
+  m_multicastList.clear();
+  Simulator::Schedule (Seconds (1), &NetlinkSocketTest::MonitorKernelChanges, this);
+  Simulator::Schedule (Seconds (2), &NetlinkSocketTest::SendCmdToKernel, this, NETLINK_RTM_NEWADDR);
+  Simulator::Schedule (Seconds (4), &NetlinkSocketTest::SendCmdToKernel, this, NETLINK_RTM_NEWROUTE);
+  Simulator::Schedule (Seconds (6), &NetlinkSocketTest::SendCmdToKernel, this, NETLINK_RTM_DELADDR);
+  Simulator::Schedule (Seconds (8), &NetlinkSocketTest::SendCmdToKernel, this, NETLINK_RTM_DELROUTE);
+
+  return result;
+};
+
+
+void
+NetlinkSocketTest::SendNetlinkMessage(NetlinkMessage nlmsg)
+{
+#if 1
+  Ptr<Packet> p = Create<Packet> ();
+  p->AddHeader (MultipartNetlinkMessage(nlmsg));
+#else
+	char buf[20] = {0x14,0x00,0x00,0x00,0x12,0x00,0x05,0x03,
+		0x34,0xb2,0xf5,0x47,0x01,0x00,0x00,0x00,
+		0x00,0x00,0x00,0x00};
+	uint32_t count = 20;
+  Ptr<Packet> p = ns3::Create<Packet> ((const uint8_t *)buf, (uint32_t)count);
+#endif
+  
+  m_cmdSock->Send (p);
+}
+void
+NetlinkSocketTest::SendCmdToKernel(uint16_t type)
+{
+  NS_LOG_INFO("At = " <<  Simulator::Now ().GetSeconds () <<"s, user send cmd to kernel, cmd = " << type);
+
+  if (type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR)
+    {
+      SendNetlinkMessage(BuildAddressMessage(type, 0));
+    }
+  else if (type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE)
+    {
+      SendNetlinkMessage(BuildRouteMessage(type, 0));
+    }
+  else
+    {
+      NS_LOG_ERROR("netlink cmd not support , type = " << type);
+    }  
+}
+
+
+void
+NetlinkSocketTest::ReceiveUnicastPacket (Ptr<Socket> socket)
+{
+  Ptr<Packet> packet;
+  while (packet = socket->Recv ())
+    {
+      MultipartNetlinkMessage nlmsg;
+      packet->RemoveHeader(nlmsg);
+      m_unicastList.push_back(nlmsg);
+    }
+}
+
+void
+NetlinkSocketTest::ReceiveMulticastPacket(Ptr<Socket> socket)
+{
+  Ptr<Packet> packet;
+  while (packet = socket->Recv ())
+    {
+      MultipartNetlinkMessage nlmsg;
+      packet->RemoveHeader(nlmsg);
+      m_multicastList.push_back(nlmsg);
+    }
+}
+void
+NetlinkSocketTest::MonitorKernelChanges()
+{
+  NS_LOG_INFO("At = " << Simulator::Now ().GetSeconds () << "s, group socket check the recv list");
+
+  if (m_multicastList.size())
+    {
+      MultipartNetlinkMessage multinlmsg = m_multicastList.front();
+
+      if (multinlmsg.GetNMessages() == 1)
+        {
+          NetlinkMessage nlmsg = multinlmsg.GetMessage(0);
+          uint16_t type = nlmsg.GetMsgType();
+          NS_ASSERT(type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR
+            || type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE);
+          NS_LOG_INFO("group socket recv netlink message, type =" << type);          
+        }
+      else
+        {
+          NS_LOG_WARN("group socket recv an unwanted message");
+        }
+      m_multicastList.pop_front();
+    }
+
+  //restart this timer
+  if (Simulator::Now ().GetSeconds () < 10)
+    Simulator::Schedule (Seconds (1), &NetlinkSocketTest::MonitorKernelChanges, this);
+}
+
+
+
+
+NetlinkSocketTest::NetlinkSocketTest ()
+: Test ("Netlink"), m_pid(1) {}
+
+bool
+NetlinkSocketTest::RunTests (void)
+{
+  bool result = true;
+
+  //init nodes with stacks and device
+  // Network topology
+  //
+  //   n0
+  //     \ 5 Mb/s, 2ms
+  //      \          1.5Mb/s, 10ms
+  //       n1 -------------------------n2
+
+
+  NodeContainer nodes; 
+  nodes.Create (3);
+  NodeContainer n0n1 = NodeContainer (nodes.Get(0), nodes.Get(1));
+  NodeContainer n1n2 = NodeContainer (nodes.Get(1), nodes.Get(2));
+
+  InternetStackHelper stack;
+  stack.Install (nodes);
+
+  NetlinkSocketHelper netlink;
+  netlink.Install(nodes);
+
+  //add a p2p device with an ip address  
+  PointToPointHelper p2p;  
+  p2p.SetDeviceAttribute("DataRate", StringValue ("5Mbps"));  
+  p2p.SetChannelAttribute ("Delay", StringValue ("2ms"));  
+  NetDeviceContainer d0d1 = p2p.Install (n0n1);
+  p2p.SetDeviceAttribute ("DataRate", StringValue ("1.5Mbps"));
+  p2p.SetChannelAttribute ("Delay", StringValue ("10ms"));
+  NetDeviceContainer d1d2 = p2p.Install (n1n2);
+
+  Ipv4AddressHelper ipv4;
+  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
+  Ipv4InterfaceContainer i01 = ipv4.Assign (d0d1);
+  ipv4.SetBase ("10.1.2.0", "255.255.255.0");
+  Ipv4InterfaceContainer i12 = ipv4.Assign (d1d2);
+
+  GlobalRouteManager::PopulateRoutingTables ();
+
+
+  /*create two netlink sockets in node1 
+  one is to exchange information between userspace and kernel ,
+  one is to monitor the changes happened in kernel
+  */
+  Ptr<Node>node0 = nodes.Get(1);
+  TypeId tid = TypeId::LookupByName ("ns3::NetlinkSocketFactory");
+  Ptr<SocketFactory> socketFactory = node0->GetObject<SocketFactory> (tid);
+  NetlinkSocketAddress addr;
+
+  /*creat an cmd netlink socket, it send cmd to kernel space*/
+  m_cmdSock = socketFactory->CreateSocket ();
+  m_cmdSock->SetRecvCallback (MakeCallback (&NetlinkSocketTest::ReceiveUnicastPacket, this)); 
+  addr.SetProcessID(m_pid);
+  addr.SetGroupsMask(0);
+  m_cmdSock->Bind(addr); 
+
+  /*creat an group netlink socket, it monitor the kernel's changes*/
+  m_groupSock = socketFactory->CreateSocket ();
+  m_groupSock->SetRecvCallback (MakeCallback (&NetlinkSocketTest::ReceiveMulticastPacket, this)); 
+  addr.SetProcessID(m_pid + 1);
+  addr.SetGroupsMask(NETLINK_RTM_GRP_IPV4_IFADDR|NETLINK_RTM_GRP_IPV4_ROUTE);
+  m_groupSock->Bind(addr); 
+
+  /*test 1: for Serialize and Deserialize*/
+  NS_TEST_ASSERT_EQUAL(TestNetlinkSerilization(), true);
+
+  /*test 2: for interface address dump/add/get message*/
+  NS_TEST_ASSERT_EQUAL(TestInterfaceAddressMessage(), true);
+
+  /*test 3: for interface info dump message*/
+  NS_TEST_ASSERT_EQUAL(TestInferfaceInfoMessage(), true);
+
+  /*test 4: for route dump/add/get message*/
+  NS_TEST_ASSERT_EQUAL(TestRouteMessage(), true);
+
+  /*test 5: for netlink broadcast */
+  NS_TEST_ASSERT_EQUAL(TestBroadcastMessage(), true);
+
+  Simulator::Run ();
+
+  return result;
+}
+
+static NetlinkSocketTest g_netlinkTest;
+
+#endif /* RUN_SELF_TESTS */
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-socket.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,1505 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+
+#include "ns3/netlink-socket.h"
+#include "ns3/netlink-socket-address.h"
+#include "ns3/netlink-message.h"
+#include "ns3/netlink-message-route.h"
+#include "ns3/netlink-ipv6-routing-table.h"
+#include "ns3/log.h"
+#include "ns3/node.h"
+#include "ns3/packet.h"
+#include "ns3/ipv4-address.h"
+#include "ns3/ipv4.h"
+#include "ns3/simple-net-device.h"
+#include "ns3/uinteger.h"
+#include "ns3/trace-source-accessor.h"
+#include <iostream>
+#include <sstream>
+#include "ns3/ipv6-address.h"
+#include "ns3/ipv6.h"
+#include "ns3/ipv4-l3-protocol.h"
+#include "ns3/ipv4-static-routing-helper.h"
+#include "ns3/ipv4-routing-table-entry.h"
+#include "ns3/ipv6-l3-protocol.h"
+#include "ns3/ipv6-interface.h"
+#include "ns3/ipv6-static-routing-helper.h"
+#include "ns3/ipv6-routing-table-entry.h"
+#include "ns3/socket.h"
+#include "ns3/mac48-address.h"
+#include <sys/socket.h>
+#include <linux/if.h>
+#include <errno.h>
+
+NS_LOG_COMPONENT_DEFINE ("NetlinkSocket");
+
+namespace ns3 {
+
+  /*
+  GroupSockets store the netlinksocket with noero group value
+  it was due to the mulitcast netlink messages.
+  */
+class GroupSockets
+{
+public:
+  static uint32_t GetNSockets(void)
+  { 
+    return m_Sockets.size();
+  }
+  static Ptr<NetlinkSocket> GetSocket(uint32_t index)
+  {
+    NS_ASSERT(index < m_Sockets.size());
+    return m_Sockets[index];
+  }
+  static void AddSocket(Ptr<NetlinkSocket>sock)
+  {
+    m_Sockets.push_back(sock);
+  }
+private:
+   /*use a std::vector to store the sockets with nozero group value*/
+  static std::vector<Ptr<NetlinkSocket> >m_Sockets;
+};
+std::vector<Ptr<NetlinkSocket> >GroupSockets::m_Sockets;
+
+
+/*
+Netlink Socket
+*/
+TypeId
+NetlinkSocket::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::NetlinkSocket")
+    .SetParent<Socket> ()
+    .AddConstructor<NetlinkSocket> ()
+    .AddTraceSource ("Drop", "Drop packet due to receive buffer overflow",
+    MakeTraceSourceAccessor (&NetlinkSocket::m_dropTrace))
+    .AddAttribute ("RcvBufSize",
+    "NetlinkSocket maximum receive buffer size (bytes)",
+    UintegerValue (0xffffffffl),
+    MakeUintegerAccessor (&NetlinkSocket::m_rcvBufSize),
+    MakeUintegerChecker<uint32_t> ())
+    .AddAttribute ("IcmpCallback", "Callback invoked whenever an icmp error is received on this socket.",
+                   CallbackValue (),
+                   MakeCallbackAccessor (&NetlinkSocket::m_icmpCallback),
+                   MakeCallbackChecker ())
+    ;
+  return tid;
+}
+NetlinkSocket::NetlinkSocket ()
+: m_shutdownSend(false),m_shutdownRecv(false),m_rxAvailable(0),
+  m_srcPid(0),m_srcGroups(0), m_dstPid(0),m_dstGroups(0)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  m_errno = ERROR_NOTERROR;
+}
+
+int 
+NetlinkSocket::ErrnoToSimuErrno (void)
+{
+  switch (m_errno) {
+  case Socket::ERROR_ISCONN:
+    return EISCONN;
+  case Socket::ERROR_NOTCONN:
+    return ENOTCONN;
+  case Socket::ERROR_MSGSIZE:
+    return EMSGSIZE;
+  case Socket::ERROR_AGAIN:
+    return EAGAIN;
+  case Socket::ERROR_SHUTDOWN:
+    return ESHUTDOWN;
+  case Socket::ERROR_OPNOTSUPP:
+    return EOPNOTSUPP;
+  case Socket::ERROR_AFNOSUPPORT:
+    return EAFNOSUPPORT;
+  case Socket::ERROR_INVAL:
+    return EINVAL;
+  case Socket::ERROR_BADF:
+    return EBADF;
+  case Socket::ERROR_NOROUTETOHOST:
+    return EHOSTUNREACH;
+  case Socket::ERROR_NODEV:
+    return ENODEV;
+  case Socket::ERROR_ADDRNOTAVAIL:
+    return EADDRNOTAVAIL;
+  case Socket::SOCKET_ERRNO_LAST:
+  case Socket::ERROR_NOTERROR:
+  default:
+    NS_ASSERT (false);
+    return 0; // quiet compiler
+    break;
+  }
+}
+
+void 
+NetlinkSocket::SetNode (Ptr<Node> node)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  m_node = node;
+}
+
+NetlinkSocket::~NetlinkSocket ()
+{
+    NS_LOG_FUNCTION_NOARGS ();
+}
+
+void 
+NetlinkSocket::DoDispose (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+}
+
+enum Socket::SocketErrno
+NetlinkSocket::GetErrno (void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_errno;
+}
+
+Ptr<Node>
+NetlinkSocket::GetNode (void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_node;
+}
+
+uint32_t
+NetlinkSocket::GetSrcPid(void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_srcPid;
+}
+uint32_t
+NetlinkSocket::GetSrcGroups(void)const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_srcGroups;
+}
+uint32_t
+NetlinkSocket::GetDstPid(void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_dstPid;
+}
+uint32_t
+NetlinkSocket::GetDstGroups(void)const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return m_dstGroups;
+}
+int
+NetlinkSocket::Bind (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  NetlinkSocketAddress address;
+  return DoBind (address);
+}
+
+int
+NetlinkSocket::Bind (const Address &address)
+{ 
+  NS_LOG_FUNCTION (this << address);
+
+  if (!NetlinkSocketAddress::IsMatchingType (address))
+    {
+      m_errno = ERROR_INVAL;
+      return -1;
+    }
+  NetlinkSocketAddress ad = NetlinkSocketAddress::ConvertFrom (address);
+
+  return DoBind (ad);
+}
+
+int
+NetlinkSocket::DoBind (const NetlinkSocketAddress &address)
+{
+  NS_LOG_FUNCTION (this << address);
+
+  m_srcPid = address.GetProcessID ();
+  m_srcGroups = address.GetGroupsMask ();
+
+  if (m_srcGroups)
+  {
+    GroupSockets::AddSocket(this);
+  } 
+
+  return 0;
+}
+int 
+NetlinkSocket::Listen(void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  m_errno = Socket::ERROR_OPNOTSUPP;
+  return -1;
+}
+uint32_t
+NetlinkSocket::GetTxAvailable(void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  return 0;
+}
+uint32_t
+NetlinkSocket::GetRxAvailable(void) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  // We separately maintain this state to avoid walking the queue 
+  // every time this might be called
+  return m_rxAvailable;
+}
+int
+NetlinkSocket::ShutdownSend (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+
+  m_shutdownSend = true;
+
+  return 0;
+}
+
+int
+NetlinkSocket::ShutdownRecv (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+
+  m_shutdownRecv = true;
+
+  return 0;
+}
+
+int
+NetlinkSocket::Close (void)
+{
+  NS_LOG_FUNCTION_NOARGS ();
+
+  ShutdownSend();
+  ShutdownRecv();
+
+  return 0;
+}
+
+int
+NetlinkSocket::Connect (const Address &address)
+{
+  NS_LOG_FUNCTION (this << address);
+  m_errno = Socket::ERROR_OPNOTSUPP;
+  return 0;
+}
+Ptr<Packet>
+NetlinkSocket::Recv (uint32_t maxSize, uint32_t flags)
+{
+  NS_LOG_FUNCTION (this << maxSize<< flags);
+  if (m_dataReceiveQueue.empty() )
+    {
+      return 0;
+    }
+
+  Ptr<Packet> p = m_dataReceiveQueue.front ();
+  if (p->GetSize () <= maxSize) 
+    {
+      m_dataReceiveQueue.pop ();
+      m_rxAvailable -= p->GetSize ();
+    }
+  else
+    {
+      p = 0; 
+    }
+
+  return p;
+}
+
+Ptr<Packet>
+NetlinkSocket::RecvFrom (uint32_t maxSize, uint32_t flags, Address &fromAddress)
+{
+  NS_LOG_FUNCTION (this << maxSize << flags << fromAddress);
+  Ptr<Packet> packet = Recv (maxSize, flags);
+  if (packet != 0)
+    {
+      SocketAddressTag tag;
+      bool found;
+      found = packet->FindFirstMatchingByteTag (tag);
+      NS_ASSERT (found);
+      fromAddress = tag.GetAddress ();
+    }
+  return packet;
+}
+
+int
+NetlinkSocket::Send (Ptr<Packet> p,uint32_t flags)
+{
+  NS_LOG_FUNCTION (this << p << flags);
+  NetlinkSocketAddress address = NetlinkSocketAddress(m_dstPid, m_dstGroups);
+
+  return SendTo(p, flags, address);
+}
+
+int
+NetlinkSocket::SendTo(Ptr<Packet> p, uint32_t flags, const Address &toAddress)
+{
+  NS_LOG_FUNCTION (this << p << flags << toAddress);
+  NetlinkSocketAddress ad;
+
+  if (!NetlinkSocketAddress::IsMatchingType (toAddress))
+    {
+        NS_LOG_LOGIC ("ERROR_AFNOSUPPORT");
+        m_errno = ERROR_AFNOSUPPORT;
+        return -1;
+    }
+  ad = NetlinkSocketAddress::ConvertFrom (toAddress);
+  m_dstPid = ad.GetProcessID();
+  m_dstGroups = ad.GetGroupsMask();
+  NS_LOG_INFO("send netlink message to pid = " << m_dstPid << ", groups = " << m_dstGroups);
+
+  //Ptr<NetlinkSocket>kernel_socket = GetNetlinkSocketByAddress(ad);
+  //kernel_socket->m_receivedData.push_back(p);
+  //kernel_socket->NotifyDataReceived(p);
+
+  //when netlink socket send packet, the first step is to find the dest netlink socket through address
+  //then send the packet to it. For we partly implement the netlink-family, the dest address
+  //is always the kernel(pid = 0), (Actually, there must be one static kernel netlink socket to
+  //receive/handle messages), we do not setup a kernel socket to receive packet.
+  //
+  
+  MultipartNetlinkMessage multipartnlmsg;
+  uint32_t packet_len, remain_len;
+
+  packet_len = p->GetSize ();
+  remain_len = packet_len;
+
+  while (remain_len > NetlinkMessageHeader::GetHeaderSize ())
+    {
+      remain_len -= p->RemoveHeader(multipartnlmsg);
+      NS_ASSERT(remain_len == p->GetSize ());
+
+      //actually, message to kernel contains single one netlink message
+      for (uint32_t i = 0; i < multipartnlmsg.GetNMessages(); i ++)
+        {
+          NetlinkMessage nlmsg = multipartnlmsg.GetMessage (i);
+
+          if (HandleMessage (nlmsg) < 0)
+            {
+              if (m_errno)
+                SendAckMessage (nlmsg, -ErrnoToSimuErrno());
+            }
+          else if (NetlinkMessage::IsMessageFlagsAck(nlmsg.GetHeader().GetMsgFlags()))
+            {
+              SendAckMessage (nlmsg, 0);
+            }
+        }
+    }
+
+  NotifyDataSent (packet_len);
+  NS_LOG_INFO("netlink socket kernel error " << -m_errno);
+  return packet_len;
+}
+
+int
+NetlinkSocket::GetSockName (Address &address) const
+{
+  NS_LOG_FUNCTION_NOARGS ();
+  NetlinkSocketAddress ad;
+
+  ad.SetProcessID(GetSrcPid());
+  ad.SetGroupsMask(GetSrcGroups());
+  address = ad;
+  return 0;
+}
+
+
+
+
+
+
+
+void
+NetlinkSocket::ForwardUp (Ptr<Packet> packet, NetlinkSocketAddress &address)
+{
+  NS_LOG_FUNCTION (this << packet << address);
+
+  if (m_shutdownRecv)
+    {
+      return;
+    }
+  if ((m_rxAvailable + packet->GetSize ()) <= m_rcvBufSize)
+    {
+      SocketAddressTag tag;
+      tag.SetAddress (address);
+      packet->AddByteTag (tag);
+      m_dataReceiveQueue.push (packet);
+      m_rxAvailable += packet->GetSize ();
+      NotifyDataRecv ();
+    }
+  else
+    {
+      NS_LOG_WARN ("No receive buffer space available.  Drop.");
+      m_dropTrace (packet);
+    }
+}
+
+
+
+
+
+
+
+
+
+int32_t
+NetlinkSocket::SendMessageUnicast (const MultipartNetlinkMessage&nlmsg, uint32_t pid, int32_t nonblock)
+{
+  NS_LOG_FUNCTION (this << pid << nonblock);
+  //here we send message instantly
+  Ptr<Packet> p = Create<Packet> ();
+  p->AddHeader (nlmsg);
+
+  NetlinkSocketAddress address;
+  address.SetProcessID(pid);
+
+  //send packet to user space
+  ForwardUp(p, address);
+
+  return 0;
+}
+
+int32_t
+NetlinkSocket::SendMessageBroadcast (const MultipartNetlinkMessage&nlmsg, 
+                                     uint32_t pid, 
+                                     uint32_t group,
+                                     Ptr<Node> node)
+{
+  NS_LOG_FUNCTION ("SendMessageBroadcast" << pid << group);
+  //fisrt find the dest netlink socket through group value, then attach this nlmsg to its recv-queue
+  for (uint32_t i = 0; i < GroupSockets::GetNSockets(); i ++)
+    {
+      Ptr<NetlinkSocket> nlsock = GroupSockets::GetSocket(i);
+
+      if ((nlsock->GetSrcGroups()&group) &&
+          (nlsock->GetSrcPid() != pid) &&
+          node == nlsock->GetNode())
+        {
+          //here we send message instantly
+          Ptr<Packet> p = Create<Packet> ();
+          p->AddHeader (nlmsg);
+
+          NetlinkSocketAddress address;
+          address.SetProcessID(nlsock->GetSrcPid());
+          address.SetGroupsMask(group);
+
+          //send packet to user space
+          nlsock->ForwardUp(p, address);
+        }
+    }
+  return 0;
+}
+void
+NetlinkSocket::SendAckMessage (const NetlinkMessage&nlmsg, int32_t err)
+{
+  NS_LOG_FUNCTION (this << err);
+  NetlinkMessageHeader rep;
+  NetlinkMessage ackmsg;
+  NetlinkMessageError errmsg;
+
+  rep.SetMsgPid(nlmsg.GetHeader().GetMsgPid());
+  rep.SetMsgSeq(nlmsg.GetHeader().GetMsgSeq());
+  rep.SetMsgType (NETLINK_MSG_ERROR);
+  rep.SetMsgFlags(0);
+
+  errmsg.SetError(err);
+  //kernel send the whole nlmsg back if error != 0, here we just send the header back
+  errmsg.SetMsg(nlmsg.GetHeader());
+
+  //then send errmsg back to user space
+  ackmsg.SetHeader(rep);
+  ackmsg.SetErrorMessage (errmsg);
+
+  SendMessageUnicast (ackmsg, rep.GetMsgPid(), 1);
+}
+
+int32_t
+NetlinkSocket::HandleMessage (const NetlinkMessage&nlmsg)
+{
+  NS_LOG_FUNCTION (this);
+  uint16_t type = nlmsg.GetMsgType ();
+  NetlinkMessageHeader nhr = nlmsg.GetHeader();
+
+  if (nhr.GetMsgLen() < NetlinkMessageHeader::GetHeaderSize ())
+    {
+      m_errno = ERROR_INVAL;
+      return -1;
+    }
+
+  if (NetlinkMessage::IsMessageNetlinkControl (type))
+    {
+      NS_LOG_INFO("netlink control message type not parsed in kernel");
+      return 0;
+    }
+  else if (NetlinkMessage::IsMessageNetlinkRoute (type))
+    {
+      return HandleNetlinkRouteMessage (nlmsg);
+    }
+  else
+    {
+      NS_LOG_INFO("netlink message type not parsed in kernel");
+      m_errno = ERROR_INVAL;
+      return -1;
+    }  
+}
+
+
+int32_t
+NetlinkSocket::HandleNetlinkRouteMessage (const NetlinkMessage&nlmsg)
+{
+  NS_LOG_FUNCTION (this);
+  uint8_t family;
+  int16_t type;
+  int32_t err;
+
+  /* Only requests are handled by kernel now */
+  if (!NetlinkMessage::IsMessageFlagsRequest(nlmsg.GetHeader().GetMsgFlags()))
+    return 0;
+
+  type = nlmsg.GetMsgType ();
+
+  /* A control message: ignore them */
+  if (NetlinkMessage::IsMessageNetlinkControl(type))
+    {
+      return 0;
+    }
+  else if (NetlinkMessage::IsMessageNetlinkRoute(type))
+    {
+      /* All the messages must have at least 1 byte length */
+      if (nlmsg.GetPayloadSize () < 1)
+        return 0;
+
+      family = nlmsg.GetFamily();
+      /*here we do not deal with different family, default for AF_NET*/
+      NS_ASSERT(family == AF_INET || family == AF_UNSPEC || family == 17 || family == AF_INET6);  
+
+      /*for GET*** message, dump it to userspace*/
+      if (NetlinkMessage::IsMessageTypeGet(type) && NetlinkMessage::IsMessageFlagsDump(nlmsg.GetHeader().GetMsgFlags())) 
+        {
+          DumpNetlinkRouteMessage (nlmsg, type, family);
+          return -1;
+        }
+
+      /* other types of messages*/
+      return DoNetlinkRouteMessage (nlmsg, type, family);
+    }
+  else/* Unknown message: reply with EINVAL */
+    {
+      err = ERROR_INVAL;
+      return -1;
+    } 
+}
+
+
+
+
+int32_t
+NetlinkSocket::DumpNetlinkRouteMessage (const NetlinkMessage&nlmsg, uint16_t type, uint8_t family)
+{
+  NS_LOG_FUNCTION (this << type << family);
+   /*the family default value was AF_INET*/
+
+  NS_ASSERT(type == NETLINK_RTM_GETADDR || type == NETLINK_RTM_GETROUTE || NETLINK_RTM_GETLINK);
+
+  MultipartNetlinkMessage nlmsg_dump;
+  NetlinkMessageHeader nhr = nlmsg.GetHeader();
+  int32_t err;
+
+  if (type == NETLINK_RTM_GETADDR)
+    {
+      nlmsg_dump = BuildInterfaceAddressDumpMessage(m_srcPid, nhr.GetMsgSeq(), family);
+    }
+  else if (type == NETLINK_RTM_GETLINK)
+    {
+      nlmsg_dump = BuildInterfaceInfoDumpMessage(m_srcPid, nhr.GetMsgSeq(), family);      
+    }
+  else if (type == NETLINK_RTM_GETROUTE)
+    {
+      nlmsg_dump = BuildRouteDumpMessage(m_srcPid, nhr.GetMsgSeq(), family);
+    }
+  else
+    {
+      m_errno = ERROR_INVAL;
+      return -1;
+    }
+
+  //then append netlink message with type NLMSG_DONE
+  {
+    NetlinkMessage nlmsg_done;
+    NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_MSG_DONE, NETLINK_MSG_F_MULTI, nlmsg.GetHeader().GetMsgSeq(), m_srcPid);
+    nlmsg_done.SetHeader(nhr);
+    //kernel append nlmsg_dump size to it, here we omit it
+    nlmsg_dump.AppendMessage (nlmsg_done);
+  }
+
+  err = SendMessageUnicast (nlmsg_dump, m_srcPid, 1);
+
+  return err;
+}
+
+
+/*here only for ADD/DEL/GET*** types*/
+int32_t
+NetlinkSocket::DoNetlinkRouteMessage (const NetlinkMessage&nlmsg, uint16_t type, uint8_t family)
+{
+  /*the family default value was AF_INET*/
+  NS_LOG_FUNCTION (this << type <<family);
+  int32_t err;
+
+  if (type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR)
+    {      
+      err = DoInterfaceAddressMessage(nlmsg, type, family);
+    }
+  else if (type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE || type == NETLINK_RTM_GETROUTE)
+    {     
+      err = DoRouteMessage(nlmsg, type, family);
+    }
+  else if (type == NETLINK_RTM_GETLINK || type == NETLINK_RTM_SETLINK)
+    {     
+      err = DoInterfaceInfoMessage(nlmsg, type, family);
+    }
+  else
+    {
+      NS_LOG_LOGIC ("netlink message:type( " << type << ") not processed by kns3 now." );
+      m_errno = ERROR_INVAL;
+      err = -1;
+    } 
+  
+  return err;
+}
+
+
+MultipartNetlinkMessage
+NetlinkSocket::BuildInterfaceAddressDumpMessage(uint32_t pid, uint32_t seq, uint8_t family)
+{
+  NS_LOG_FUNCTION (this << pid << seq <<family);
+  /*the family default value was AF_INET*/
+  MultipartNetlinkMessage nlmsg_dump;
+  Ptr<Ipv4>ipv4 = m_node->GetObject<Ipv4> ();
+
+  for (uint32_t i = 0; i < ipv4->GetNInterfaces(); i ++)
+    {
+      if (!ipv4->IsUp (i))
+        continue;
+
+      Ipv4Address addri = ipv4->GetAddress (i, 0).GetLocal();
+      Ipv4Mask maski = ipv4->GetAddress (i, 0).GetMask ();
+      Ipv4Address bcast = ipv4->GetAddress (i, 0).GetBroadcast();
+
+      //loopback and broadcast address not dumped
+      if (addri.IsEqual(Ipv4Address::GetLoopback()) || addri.IsBroadcast())
+        continue;
+      
+      //here get the address mask length
+      uint32_t mask = maski.Get();
+      uint8_t mask_len = 0;
+      while (mask)
+        {
+          mask = mask << 1;
+          mask_len ++;
+        }
+      
+      //next fill the message body
+      NetlinkMessage nlmsg_ifa;
+      NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWADDR, NETLINK_MSG_F_MULTI, seq, pid);
+      InterfaceAddressMessage ifamsg;       
+
+      ifamsg.SetInterfaceIndex(i);
+      ifamsg.SetFamily(PF_INET);//default AF_INET      
+      ifamsg.SetLength(mask_len);
+      ifamsg.SetFlags(0);
+      ifamsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+
+      ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_LOCAL,    ADDRESS, addri));
+      ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_ADDRESS,  ADDRESS, addri));
+      ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_BROADCAST,ADDRESS, bcast));
+      //      ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_LABEL,    STRING,  "ns3-ifaddr"));//not used in ns3
+      //ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_ANYCAST,  ADDRESS, Ipv4Address("0.0.0.0")));//not used in ns3
+      //XXXother attributes not used by ns3
+
+      nlmsg_ifa.SetHeader(nhr);
+      nlmsg_ifa.SetInterfaceAddressMessage (ifamsg);
+      nlmsg_dump.AppendMessage (nlmsg_ifa);
+    }
+
+  // For IPv6
+  Ptr<Ipv6>ipv6 = m_node->GetObject<Ipv6> ();
+
+  for (uint32_t i = 0; i < ipv6->GetNInterfaces(); i ++)
+    {
+      if (!ipv6->IsUp (i))
+        continue;
+
+      for (uint32_t j = 0; j < ipv6->GetNAddresses(i); j ++)
+        {
+          Ipv6Address addri = ipv6->GetAddress (i, j).GetAddress();
+          Ipv6Prefix prefix = ipv6->GetAddress (i, j).GetPrefix ();
+
+          //here get the address mask length
+          uint8_t mask_len = prefix.PrefixLen();
+
+          //loopback address's prefix is wrong... FIXME
+          if (addri.IsEqual(Ipv6Address::GetLoopback()))
+            mask_len = 128;
+      
+          //next fill the message body
+          NetlinkMessage nlmsg_ifa;
+          NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWADDR, NETLINK_MSG_F_MULTI, seq, pid);
+          InterfaceAddressMessage ifamsg;       
+
+          ifamsg.SetInterfaceIndex(i);
+          ifamsg.SetFamily(AF_INET6);
+          ifamsg.SetFlags(0);
+
+
+          if (addri.IsLinkLocal())
+            {
+              ifamsg.SetLength(64);
+              ifamsg.SetScope (RouteMessage::RT_SCOPE_LINK);
+            }
+          else
+            {
+              ifamsg.SetLength(mask_len);
+              ifamsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+            }
+
+
+          ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_LOCAL,    ADDRESS, addri));
+          ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_ADDRESS,  ADDRESS, addri));
+          //XXXother attributes not used by ns3
+
+          nlmsg_ifa.SetHeader(nhr);
+          nlmsg_ifa.SetInterfaceAddressMessage (ifamsg);
+          nlmsg_dump.AppendMessage (nlmsg_ifa);
+        }
+
+    }
+
+  return nlmsg_dump;
+}
+MultipartNetlinkMessage
+NetlinkSocket::BuildInterfaceInfoDumpMessage(uint32_t pid, uint32_t seq, uint8_t family)
+{
+  NS_LOG_FUNCTION (this << pid << seq <<family);
+  /*the family default value was AF_INET*/
+  MultipartNetlinkMessage nlmsg_dump;
+  Ptr<Ipv6>ipv6 = m_node->GetObject<Ipv6> ();
+
+  for (uint32_t i = 0; i < ipv6->GetNInterfaces(); i ++)
+    {
+      Ptr<NetDevice> nd = ipv6->GetNetDevice (i);
+
+      Address mac;
+      Address bcast;
+      uint32_t mtu;
+      uint32_t flags = 0;
+
+      if(ipv6->IsUp(i))
+        flags |= IFF_UP;
+
+      if(nd){
+        mac = nd->GetAddress();
+        bcast = nd->GetBroadcast();
+        mtu = (uint32_t)nd->GetMtu();
+
+        if(nd->IsBroadcast())
+          flags |= IFF_BROADCAST;
+        if(nd->IsMulticast())
+          flags |= IFF_MULTICAST;
+        if(nd->IsLinkUp())
+          flags |= IFF_RUNNING;
+      }
+      else{
+        mac = bcast = Mac48Address("00:00:00:00:00:00");
+        mtu = 16436;
+        flags = IFF_UP|IFF_BROADCAST|IFF_MULTICAST|IFF_RUNNING;
+      }
+
+      NetlinkMessage nlmsg_ifinfo;
+      NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWLINK, NETLINK_MSG_F_MULTI, seq, pid);
+      InterfaceInfoMessage ifinfomsg;     
+
+      ifinfomsg.SetFamily(0);//AF_UNSPEC
+      ifinfomsg.SetDeviceType (0);//not clear
+      ifinfomsg.SetInterfaceIndex(i);
+      ifinfomsg.SetDeviceFlags(flags);//not clear
+      ifinfomsg.SetChangeMask(0xffffffff);
+
+      // the ns3 device have no  name, here we set "ns3-device i" for test
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_IFNAME,    STRING,  nd->GetName ()));
+      std::stringstream ss;
+      ss <<  "ns3-device" << i;
+
+      ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_IFNAME,    STRING,  ss.str()));
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_TXQLEN,    U32,     0));//not used in ns3
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_WEIGHT,    U32,     0));//not used in ns3
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_OPERSTATE, U8,      0));//not used in ns3
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_LINKMODE,  U8,      0));//not used in ns3
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_MAP,       UNSPEC,  0));//not used in ns3
+      ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_ADDRESS,   ADDRESS, mac));
+      ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_BROADCAST, ADDRESS, bcast));
+      ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_MTU,       U32,     mtu));
+      ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_LINK,      U32,     i));//not used in ns3
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_QDISC,     STRING,  ""));//not used in ns3
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_MASTER,    U32,     0));//not used in ns3
+      //ifinfomsg.AppendAttribute (NetlinkAttribute (InterfaceInfoMessage::IFL_A_STATS,     UNSPEC,  0));//not used in ns3
+      //XXXother attributes not used by ns3
+
+      nlmsg_ifinfo.SetHeader(nhr);
+      nlmsg_ifinfo.SetInterfaceInfoMessage (ifinfomsg);
+      nlmsg_dump.AppendMessage (nlmsg_ifinfo);
+    }
+
+  return nlmsg_dump;
+}
+MultipartNetlinkMessage
+NetlinkSocket::BuildRouteDumpMessage(uint32_t pid, uint32_t seq, uint8_t family)
+{
+  NS_LOG_FUNCTION (this << pid << seq <<family);
+  /*the family default value was AF_INET*/
+  MultipartNetlinkMessage nlmsg_dump;
+
+  Ptr<Ipv4>ipv4 = m_node->GetObject<Ipv4> ();
+
+#if 0
+  Ptr<Ipv4RoutingProtocol> routing = ipv4->GetRoutingProtocol ();
+  for (uint32_t i = 0; i < routing->GetNRoutes(); i ++)
+    {
+      NetlinkMessage nlmsg_rt;
+      NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWROUTE, NETLINK_MSG_F_MULTI, seq, pid);
+      RouteMessage rtmsg;
+      Ipv4RoutingTableEntry route = routing->GetRoute (i);
+
+      if (route.GetDest().IsEqual(Ipv4Address::GetLoopback()))//ignore loopback route
+        continue;
+
+      rtmsg.SetFamily(PF_INET);//AF_INET
+      rtmsg.SetDstLength(32);
+      rtmsg.SetSrcLength(0);
+      rtmsg.SetTos(0);//not clear
+      rtmsg.SetTableId(RouteMessage::RT_TABLE_MAIN);
+      rtmsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+      rtmsg.SetProtocol (RouteMessage::RT_PROT_UNSPEC);
+      rtmsg.SetFlags(RouteMessage::RT_F_CLONED);
+
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_DST, ADDRESS, route.GetDest ()));
+      //ns3 use local address as the route src address
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_SRC, ADDRESS, route.GetSource ()));
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_PREFSRC, ADDRESS, route.GetSource()));//not used in ns3
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_IIF, U32, route.GetInterface()));
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_OIF, U32, route.GetInterface()));      
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_GATEWAY, ADDRESS, route.GetGateway()));
+      //XXXother attributes not used by ns3
+
+      nlmsg_rt.SetHeader(nhr);
+      nlmsg_rt.SetRouteMessage (rtmsg);
+      nlmsg_dump.AppendMessage (nlmsg_rt);
+    }
+#endif
+
+  // V4 static
+  Ipv4StaticRoutingHelper routingHelper;
+  Ptr<Ipv4StaticRouting> ipv4Static = routingHelper.GetStaticRouting (ipv4);
+  for (uint32_t i = 0; i < ipv4Static->GetNRoutes(); i ++)
+    {
+      NetlinkMessage nlmsg_rt;
+      NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWROUTE, NETLINK_MSG_F_MULTI, seq, pid);
+      RouteMessage rtmsg;
+      Ipv4RoutingTableEntry route = ipv4Static->GetRoute (i);
+
+      if (route.GetDest().IsEqual(Ipv4Address::GetLoopback()))//ignore loopback route
+        continue;
+
+      rtmsg.SetFamily(PF_INET);//AF_INET
+      rtmsg.SetDstLength(32);
+      rtmsg.SetSrcLength(0);
+      rtmsg.SetTos(0);//not clear
+      rtmsg.SetTableId(RouteMessage::RT_TABLE_MAIN);
+      rtmsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+      rtmsg.SetProtocol (RouteMessage::RT_PROT_UNSPEC);
+      rtmsg.SetFlags(RouteMessage::RT_F_CLONED);
+
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_DST, ADDRESS, route.GetDest ()));
+      //ns3 use local address as the route src address
+      //      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_SRC, ADDRESS, route.GetSource()));
+      //      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_PREFSRC, ADDRESS, route.GetSource()));//not used in ns3
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_IIF, U32, route.GetInterface()));
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_OIF, U32, route.GetInterface()));      
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_GATEWAY, ADDRESS, route.GetGateway()));
+      //XXXother attributes not used by ns3
+
+      nlmsg_rt.SetHeader(nhr);
+      nlmsg_rt.SetRouteMessage (rtmsg);
+      nlmsg_dump.AppendMessage (nlmsg_rt);
+    }
+
+  Ptr<Ipv6>ipv6 = m_node->GetObject<Ipv6> ();
+#if 0
+  for (uint32_t i = 0; i < ipv6->GetNRoutes(); i ++)
+    {
+      NetlinkMessage nlmsg_rt;
+      NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWROUTE, NETLINK_MSG_F_MULTI, seq, pid);
+      RouteMessage rtmsg;
+      Ipv6Route route = ipv6->GetRoute (i);
+
+      if (route.GetDest().IsEqual(Ipv6Address::GetLoopback()))//ignore loopback route
+        continue;
+
+      rtmsg.SetFamily(AF_INET6);//AF_INET6
+      rtmsg.SetDstLength(128);
+      rtmsg.SetSrcLength(0);
+      rtmsg.SetTos(0);//not clear
+      rtmsg.SetTableId(RouteMessage::RT_TABLE_MAIN);
+      rtmsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+      rtmsg.SetProtocol (RouteMessage::RT_PROT_UNSPEC);
+      rtmsg.SetFlags(RouteMessage::RT_F_CLONED);
+
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_DST, ADDRESS, route.GetDest ()));
+      //ns3 use local address as the route src address
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_SRC, ADDRESS, ipv6->GetSourceAddress(route.GetDest ())));
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_PREFSRC, ADDRESS, ipv6->GetSourceAddress(route.GetDest ())));//not used in ns3
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_IIF, U32, route.GetInterface()));
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_OIF, U32, route.GetInterface()));      
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_GATEWAY, ADDRESS, route.GetGateway()));
+      //XXXother attributes not used by ns3
+
+      nlmsg_rt.SetHeader(nhr);
+      nlmsg_rt.SetRouteMessage (rtmsg);
+      nlmsg_dump.AppendMessage (nlmsg_rt);
+    }
+#endif
+
+  // V6 static
+  Ptr<NetlinkIpv6RoutingTable> ipv6Table = m_node->GetObject<NetlinkIpv6RoutingTable> ();
+  for (uint32_t i = 0; i < ipv6Table->GetNRoutes(); i ++)
+    {
+      NetlinkMessage nlmsg_rt;
+      NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWROUTE, NETLINK_MSG_F_MULTI, seq, pid);
+      RouteMessage rtmsg;
+      Ipv6RoutingTableEntry route = ipv6Table->GetRoute (i);
+
+      if (route.GetDest().IsEqual(Ipv6Address::GetLoopback()))//ignore loopback route
+        continue;
+
+      rtmsg.SetFamily(AF_INET6);//AF_INET6
+      rtmsg.SetDstLength(128);
+      rtmsg.SetSrcLength(0);
+      rtmsg.SetTos(0);//not clear
+      rtmsg.SetTableId(RouteMessage::RT_TABLE_MAIN);
+      rtmsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+      rtmsg.SetProtocol (RouteMessage::RT_PROT_UNSPEC);
+      rtmsg.SetFlags(RouteMessage::RT_F_CLONED);
+
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_DST, ADDRESS, route.GetDest ()));
+      //ns3 use local address as the route src address
+      //      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_SRC, ADDRESS, ipv6->GetSourceAddress(route.GetDest ())));
+      //      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_PREFSRC, ADDRESS, ipv6->GetSourceAddress(route.GetDest ())));//not used in ns3
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_IIF, U32, route.GetInterface()));
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_OIF, U32, route.GetInterface()));      
+      rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_GATEWAY, ADDRESS, route.GetGateway()));
+      //XXXother attributes not used by ns3
+
+      nlmsg_rt.SetHeader(nhr);
+      nlmsg_rt.SetRouteMessage (rtmsg);
+      nlmsg_dump.AppendMessage (nlmsg_rt);
+    }
+
+  return nlmsg_dump;
+}
+
+
+int32_t
+NetlinkSocket::DoInterfaceAddressMessage(const NetlinkMessage&nlmsg, uint16_t type, uint8_t family)
+{
+  NS_LOG_FUNCTION (this << type << family);
+  NS_ASSERT(type == NETLINK_RTM_NEWADDR || type == NETLINK_RTM_DELADDR);
+
+  InterfaceAddressMessage ifamsg = nlmsg.GetInterfaceAddressMessage ();
+  Ipv4Address addri, addr_local, bcast;
+  NetlinkAttribute attr_local;
+  uint32_t index = ifamsg.GetInterfaceIndex();
+  Ptr<Ipv4>ipv4 = m_node->GetObject<Ipv4> ();
+  int flag4 = 0, flag6 = 0;
+
+  if (type == NETLINK_RTM_NEWADDR)
+    {
+      //when adding an interface address, it should check the input arguments
+      //prefix-len and local address attribute
+      if (ifamsg.GetLength() > 32 || ifamsg.GetAttributeByType(attr_local, InterfaceAddressMessage::IF_A_LOCAL) == false)
+        {
+          m_errno = ERROR_INVAL;
+          return -1;
+        }
+    }  
+
+  //get necessary information for add/del, many attributes we not used
+  for (uint32_t i = 0; i < ifamsg.GetNNetlinkAttribute (); i ++)
+    {
+      NetlinkAttribute attr = ifamsg.GetNetlinkAttribute (i);
+
+      uint32_t attr_type = attr.GetAttrType ();
+
+      switch(attr_type)
+        {
+        case InterfaceAddressMessage::IF_A_ADDRESS:
+          addri = Ipv4Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          break;
+        case InterfaceAddressMessage::IF_A_BROADCAST:
+          bcast = Ipv4Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          break;
+        case InterfaceAddressMessage::IF_A_LOCAL:
+          addr_local = Ipv4Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          break;
+        case InterfaceAddressMessage::IF_A_LABEL:
+        case InterfaceAddressMessage::IF_A_ANYCAST:
+          break;
+        }
+    }
+
+  if (type == NETLINK_RTM_NEWADDR)
+    {
+      //when adding an interface address by index, if the indexed interface was not exist,
+      //create an new NetDevice with an new index and set the address
+      //otherwise set the indexed interface directly
+      if (index >= ipv4->GetNInterfaces())
+        {          
+          Ptr<SimpleNetDevice> dev;
+          dev = CreateObject<SimpleNetDevice> ();
+          dev ->SetAddress (Mac48Address::Allocate ());
+          m_node->AddDevice (dev);
+
+          uint32_t netdev_idx = ipv4->AddInterface (dev);
+          // FIXME!
+          Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (addri, Ipv4Mask());
+          ipv4->AddAddress (netdev_idx, ipv4Addr);
+          ipv4->SetUp (netdev_idx);
+          NS_LOG_INFO("Add an interface address at index "<< netdev_idx << "but not the ifamsg input" << index);
+        }
+      else
+        {
+          Ipv4InterfaceAddress ipv4Addr = Ipv4InterfaceAddress (addri, Ipv4Mask());
+          ipv4->AddAddress (index, ipv4Addr);
+          if (!ipv4->IsUp (index))
+            ipv4->SetUp (index);        
+        }    
+      flag4 = 1;
+    }
+  else//type == NETLINK_RTM_DELADDR
+    {
+      //when delete an interface address by index, if the indexed interface  was not exist
+      //return an error EINVAL, otherwise set down the interface which has the addri
+      if (index >= ipv4->GetNInterfaces())
+        {
+          m_errno = ERROR_NODEV;
+          return -1;
+        }
+      else
+        {
+          for (uint32_t i = 0; i < ipv4->GetNInterfaces(); i ++)
+            {
+              Ipv4Address ad = ipv4->GetAddress (i, 0).GetLocal ();
+
+              if (ad == addri && ipv4->IsUp(i))
+                {
+                  ipv4->SetDown(i);
+                  break;
+                }
+
+              if ( i == ipv4->GetNInterfaces() - 1)
+                {
+                  m_errno = ERROR_ADDRNOTAVAIL;
+                  return -1;
+                }
+            }
+          flag4 = 1;
+        }      
+    }
+
+  //then send an broadcast message, let all user know this operation happened
+  NetlinkMessage nlmsg_broadcast = nlmsg;
+  NetlinkMessageHeader nhr;
+  nhr.SetMsgLen(nlmsg.GetHeader().GetMsgLen());
+  nhr.SetMsgType(nlmsg.GetHeader().GetMsgType());
+  nlmsg_broadcast.SetHeader(nhr);
+  if(flag4)
+    SendMessageBroadcast(nlmsg_broadcast, 0, NETLINK_RTM_GRP_IPV4_IFADDR, GetNode());  
+  else if(flag6)
+    SendMessageBroadcast(nlmsg_broadcast, 0, RTMGRP_IPV6_IFADDR, GetNode());  
+
+  return 0;
+}
+
+int32_t
+NetlinkSocket::DoInterfaceInfoMessage(const NetlinkMessage&nlmsg, uint16_t type, uint8_t family)
+{
+  NS_LOG_FUNCTION (this << type << family);
+  NS_ASSERT(type == NETLINK_RTM_GETLINK || type == NETLINK_RTM_SETLINK);
+  InterfaceInfoMessage ifinfomsg = nlmsg.GetInterfaceInfoMessage();
+  //XXX
+  NS_LOG_INFO("ns3 not handle these types of messages.");
+  return -1;
+}
+int32_t
+NetlinkSocket::DoRouteMessage(const NetlinkMessage&nlmsg, uint16_t type, uint8_t family)
+{
+  NS_LOG_FUNCTION (this << type << family);
+  NS_ASSERT(type == NETLINK_RTM_NEWROUTE || type == NETLINK_RTM_DELROUTE ||type == NETLINK_RTM_GETROUTE);
+
+  RouteMessage rtmsg = nlmsg.GetRouteMessage ();
+  Ipv4Address src,dest,gateway;
+  Ipv6Address src6,dest6,gateway6;
+  uint32_t index;
+  int attr_flags[RouteMessage::RT_A_MAX] = {0};
+  uint8_t dstlen = rtmsg.GetDstLength();
+
+  //get necessary information for add/del, many attributes we not used
+  for (uint32_t i = 0; i < rtmsg.GetNNetlinkAttribute (); i ++)
+    {
+      NetlinkAttribute attr = rtmsg.GetNetlinkAttribute (i);
+      uint32_t attr_type = attr.GetAttrType ();
+      attr_flags[attr_type] = 1;
+      
+
+      switch(attr_type)
+        {
+        case RouteMessage::RT_A_DST:
+          if(family == AF_INET)
+            dest = Ipv4Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          else if(family == AF_INET6)
+            dest6 = Ipv6Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          break;
+        case RouteMessage::RT_A_SRC:
+          if(family == AF_INET)
+            src = Ipv4Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          else if(family == AF_INET6)
+            src6 = Ipv6Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          break;
+        case RouteMessage::RT_A_OIF:
+          index = attr.GetAttrPayload().GetU32();
+          break;
+        case RouteMessage::RT_A_GATEWAY:
+          if(family == AF_INET)
+            gateway = Ipv4Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          else if(family == AF_INET6)
+            gateway6 = Ipv6Address::ConvertFrom(attr.GetAttrPayload().GetAddress());
+          break;
+        case RouteMessage::RT_A_IIF:
+        case RouteMessage::RT_A_PRIORITY:
+        case RouteMessage::RT_A_PREFSRC:
+        case RouteMessage::RT_A_METRICS:
+        case RouteMessage::RT_A_MULTIPATH:
+        case RouteMessage::RT_A_PROTOINFO:
+        case RouteMessage::RT_A_FLOW:
+        case RouteMessage::RT_A_CACHEINFO:
+        case RouteMessage::RT_A_SESSION:
+        case RouteMessage::RT_A_MP_ALGO:
+        case RouteMessage::RT_A_TABLE:
+          NS_LOG_INFO("route attribute not used by ns3" << attr_type);
+          //not used by ns3
+          break;
+        }
+    }
+
+  // Sigh....
+  Ptr<Ipv4>ipv4 = m_node->GetObject<Ipv4> ();
+  Ipv4StaticRoutingHelper routingHelper;
+  Ptr<Ipv4StaticRouting> ipv4Static = routingHelper.GetStaticRouting (ipv4);
+
+  Ptr<Ipv6>ipv6 = m_node->GetObject<Ipv6> ();
+  Ptr<NetlinkIpv6RoutingTable> ipv6Table = m_node->GetObject<NetlinkIpv6RoutingTable> ();
+
+  if (type == NETLINK_RTM_NEWROUTE)
+    {       
+      //ns3 add a route entry only depends on 2 or 3 attribute
+      //other route msg attibute were ignored
+      if (attr_flags[RouteMessage::RT_A_DST])
+        {
+          if(family == AF_INET){
+            if(!attr_flags[RouteMessage::RT_A_OIF]){
+              // FIXME
+#if 0
+              if(ipv4->GetInterfaceForDestination(gateway, index) == false){
+                NS_LOG_INFO("No suitable interface to add an route entry");
+                m_errno = ERROR_ADDRNOTAVAIL;
+                return -1;         
+              }
+#endif
+            }
+
+            if(dstlen == 32){
+              if (attr_flags[RouteMessage::RT_A_GATEWAY])
+                ipv4Static->AddHostRouteTo(dest, gateway, index);
+              else
+                ipv4Static->AddHostRouteTo(dest, index);
+            }
+            else{
+              // FIXME
+              if (attr_flags[RouteMessage::RT_A_GATEWAY])
+                ipv4Static->AddNetworkRouteTo(dest, Ipv4Mask (1), gateway, index);
+              else
+                ipv4Static->AddNetworkRouteTo(dest, Ipv4Mask (1), index);
+            }
+          }
+          else if(family == AF_INET6){
+            if(!attr_flags[RouteMessage::RT_A_OIF]){
+#if 0
+              if(ipv6->GetIfIndexForDestination(gateway6, index) == false){
+                NS_LOG_INFO("No suitable interface to add an route entry");
+                m_errno = ERROR_ADDRNOTAVAIL;
+                return -1;         
+              }
+#endif
+            }
+
+            Ipv6Prefix pref(dstlen);
+            if (attr_flags[RouteMessage::RT_A_GATEWAY])
+              ipv6Table->AddRouteTo (dest6, pref, gateway6, index);
+            else
+              ipv6Table->AddRouteTo (dest6, pref, Ipv6Address("::"), index);
+          }
+        }
+      else
+        {
+          NS_LOG_INFO("too few attributes to add an route entry");
+          m_errno = ERROR_INVAL;
+          return -1;         
+        }      
+    }
+  else if (type == NETLINK_RTM_DELROUTE)
+    {
+      if (attr_flags[RouteMessage::RT_A_DST])
+        {
+          int delete_flag = 0;
+
+          if(family == AF_INET){
+            for (uint32_t i = 0; i < ipv4Static->GetNRoutes(); i ++)
+              {
+                Ipv4RoutingTableEntry rt = ipv4Static->GetRoute(i);
+
+                if (gateway == rt.GetGateway() && dest == rt.GetDest())
+                  {
+                    ipv4Static->RemoveRoute(i);
+                    delete_flag = 1;
+                  }
+              }
+          }
+          else if(family == AF_INET6){
+            ipv6Table->RemoveRoute(dest6);
+            delete_flag = 1;
+          }
+
+          if (!delete_flag)
+            {
+              NS_LOG_INFO("no route entry removed by dest address" << dest);
+              m_errno = ERROR_INVAL;
+              return -1;    
+            }      
+        }
+      else
+        {
+            NS_LOG_INFO("too few attributes to add an route entry");
+            m_errno = ERROR_INVAL;
+            return -1;    
+        }
+    }
+  else// type == NETLINK_RTM_GETROUTE
+    {
+      if (!attr_flags[RouteMessage::RT_A_DST])
+        {
+          NS_LOG_INFO("too few attributes to get an route entry");
+          m_errno = ERROR_INVAL;
+          return -1;   
+        }
+
+      int get_flag = 0;
+      if(family == AF_INET){
+        for (uint32_t i = 0; i < ipv4Static->GetNRoutes(); i ++)
+          {
+            Ipv4RoutingTableEntry route = ipv4Static->GetRoute (i);
+            //find the route entry with same dest address and send unicast to user space
+            if (dest.IsEqual(route.GetDest()))
+              {
+                //                Ptr<Ipv4>ipv4 = m_node->GetObject<Ipv4> ();
+                NetlinkMessage nlmsg_route;
+                NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWROUTE, 0, nlmsg.GetHeader().GetMsgSeq(), m_srcPid);
+                RouteMessage rtmsg;         
+
+                //fill rtmsg and attributes
+                rtmsg.SetFamily(AF_INET);//AF_INET
+                rtmsg.SetDstLength(32);
+                rtmsg.SetSrcLength(0);
+                rtmsg.SetTos(0);//not clear
+                rtmsg.SetTableId(RouteMessage::RT_TABLE_MAIN);
+                rtmsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+                rtmsg.SetProtocol (RouteMessage::RT_PROT_UNSPEC);
+                rtmsg.SetFlags(RouteMessage::RT_F_CLONED);
+
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_DST, ADDRESS, route.GetDest ()));
+                //ns3 use local address as the route src address
+                //                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_SRC, ADDRESS, ipv4->GetSourceAddress(route.GetDest ())));
+                //                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_PREFSRC, ADDRESS, ipv4->GetSourceAddress(route.GetDest ())));//not used in ns3
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_IIF, U32, route.GetInterface ()));
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_OIF, U32, route.GetInterface ()));
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_GATEWAY, ADDRESS, route.GetGateway ()));
+                //XXX..other attributes not used by ns3
+
+                //fill an netlink message body
+                nlmsg_route.SetHeader(nhr);
+                nlmsg_route.SetRouteMessage (rtmsg);
+
+                SendMessageUnicast (nlmsg_route, m_srcPid, 1);
+                get_flag = 1;
+              }
+          }
+      }
+      else if(family == AF_INET6){
+        for (uint32_t i = 0; i < ipv6Table->GetNRoutes(); i ++)
+          {
+            Ipv6RoutingTableEntry route = ipv6Table->GetRoute (i);
+            //find the route entry with same dest address and send unicast to user space
+            if (dest6.IsEqual(route.GetDest()))
+              {
+                NetlinkMessage nlmsg_route;
+                NetlinkMessageHeader nhr = NetlinkMessageHeader(NETLINK_RTM_NEWROUTE, 0, nlmsg.GetHeader().GetMsgSeq(), m_srcPid);
+                RouteMessage rtmsg;         
+
+                //fill rtmsg and attributes
+                rtmsg.SetFamily(AF_INET6);//AF_INET6
+                rtmsg.SetDstLength(32);
+                rtmsg.SetSrcLength(0);
+                rtmsg.SetTos(0);//not clear
+                rtmsg.SetTableId(RouteMessage::RT_TABLE_MAIN);
+                rtmsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+                rtmsg.SetProtocol (RouteMessage::RT_PROT_UNSPEC);
+                rtmsg.SetFlags(RouteMessage::RT_F_CLONED);
+
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_DST, ADDRESS, route.GetDest ()));
+                //ns3 use local address as the route src address
+                //                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_SRC, ADDRESS, ipv6->GetSourceAddress(route.GetDest ())));
+                //                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_PREFSRC, ADDRESS, ipv6->GetSourceAddress(route.GetDest ())));//not used in ns3
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_IIF, U32, route.GetInterface ()));
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_OIF, U32, route.GetInterface ()));
+                rtmsg.AppendAttribute (NetlinkAttribute (RouteMessage::RT_A_GATEWAY, ADDRESS, route.GetGateway ()));
+                //XXX..other attributes not used by ns3
+
+                //fill an netlink message body
+                nlmsg_route.SetHeader(nhr);
+                nlmsg_route.SetRouteMessage (rtmsg);
+
+                SendMessageUnicast (nlmsg_route, m_srcPid, 1);
+                get_flag = 1;
+              }
+          }
+      }
+
+      if(!get_flag)
+        {
+          NS_LOG_INFO("no route entry exist by dest address" << dest);
+          m_errno = ERROR_INVAL;
+          return -1;  
+        }
+    }
+
+  //then send an broadcast message, let all user know this operation happened
+  NetlinkMessage nlmsg_broadcast = nlmsg;
+  NetlinkMessageHeader nhr;
+  nhr.SetMsgLen(nlmsg.GetHeader().GetMsgLen());
+  nhr.SetMsgType(nlmsg.GetHeader().GetMsgType());
+  nlmsg_broadcast.SetHeader(nhr);
+//   SendMessageBroadcast(nlmsg_broadcast, 0, NETLINK_RTM_GRP_IPV4_ROUTE);  
+//   SendMessageBroadcast(nlmsg_broadcast, 0, RTMGRP_IPV6_ROUTE);
+  return 0;
+}
+
+#if 0
+device->SetLinkChangeCallback(MakeCallback(&NdiscCache::Flush, cache));
+int32_t
+NetlinkSocket::NotifyIfLinkMessage(Address address, uint16_t type, uint8_t family)
+{
+}
+#endif
+int32_t
+NetlinkSocket::NotifyIfAddrMessage(Ipv6Interface* interface, Ipv6Address addr, int cmd)
+{
+  MultipartNetlinkMessage nlmsg_multi;
+  NetlinkMessage nlmsg_ifa;
+  NetlinkMessageHeader nhr = NetlinkMessageHeader(cmd, NETLINK_MSG_F_MULTI, 0, 0);
+  InterfaceAddressMessage ifamsg;       
+
+  // FIXME!
+  Ipv6Prefix prefix = Ipv6Prefix(64);
+
+  //loopback address not dumped
+  if (addr.IsEqual(Ipv6Address::GetLoopback()))
+    return -1;
+      
+  //here get the address mask length
+  uint8_t bytes[16];
+  prefix.GetBytes(bytes);
+  uint8_t mask_len = 0;
+  for (int j = 0; j < 16; j++){
+    while (bytes[j])
+      {
+        bytes[j] = bytes[j] << 1;
+        mask_len ++;
+      }
+  }
+      
+
+  ifamsg.SetInterfaceIndex(interface->GetDevice()->GetIfIndex());
+  ifamsg.SetFamily(AF_INET6);
+  ifamsg.SetLength(mask_len);
+  ifamsg.SetFlags(0);
+  ifamsg.SetScope (RouteMessage::RT_SCOPE_UNIVERSE);
+
+  ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_LOCAL,    ADDRESS, addr));
+  ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_ADDRESS,  ADDRESS, addr));
+  //  ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_BROADCAST,ADDRESS, bcast));
+  //      ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_LABEL,    STRING,  "ns3-ifaddr"));//not used in ns3
+  //ifamsg.AppendAttribute (NetlinkAttribute (InterfaceAddressMessage::IF_A_ANYCAST,  ADDRESS, Ipv4Address("0.0.0.0")));//not used in ns3
+  //XXXother attributes not used by ns3
+
+  nlmsg_ifa.SetHeader(nhr);
+  nlmsg_ifa.SetInterfaceAddressMessage (ifamsg);
+
+  NetlinkMessage nlmsg_done;
+  NetlinkMessageHeader nhr_done = NetlinkMessageHeader(NETLINK_MSG_DONE, NETLINK_MSG_F_MULTI, 0, 0);
+  nlmsg_done.SetHeader(nhr_done);
+
+  nlmsg_multi.AppendMessage (nlmsg_ifa);
+  nlmsg_multi.AppendMessage (nlmsg_done);
+
+  SendMessageBroadcast(nlmsg_multi, 0, RTMGRP_IPV6_IFADDR, interface->GetDevice()->GetNode());  
+
+  return 0;
+}
+#if 0
+int32_t
+NetlinkSocket::NotifyRouteMessage(Ojbect route, uint16_t type, uint8_t family)
+{
+  NetlinkMessage nlmsg_broadcast = nlmsg;
+  NetlinkMessageHeader nhr;
+  nhr.SetMsgLen(nlmsg.GetHeader().GetMsgLen());
+  nhr.SetMsgType(nlmsg.GetHeader().GetMsgType());
+  nlmsg_broadcast.SetHeader(nhr);
+  SendMessageBroadcast(nlmsg_broadcast, 0, RTMGRP_IPV6_ROUTE);
+}
+#endif
+}//namespace ns3
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/netlink-socket.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,196 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+* Copyright (c) 2008 Liu Jian
+*
+* 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: Liu Jian <liujatp@gmail.com>
+*/
+#ifndef NETLINK_SOCKET_H
+#define NETLINK_SOCKET_H
+
+#include <stdint.h>
+#include <queue>
+#include "ns3/callback.h"
+#include "ns3/ptr.h"
+#include "ns3/traced-callback.h"
+#include "ns3/socket.h"
+#include "ns3/netlink-message.h"
+#include "ns3/ipv4-address.h"
+#include "ns3/ipv6-address.h"
+#include "ns3/ipv6-interface.h"
+namespace ns3 {
+
+class Node;
+class Packet;
+class NetlinkSocketAddress;
+
+/**
+* \brief A NetlinkSocket is  used  to transfer information 
+between kernel and userspace processes .
+*
+* here we focus on NETLINK_ROUTE: Receives routing and link
+* updates and may be used to modify  the  routing  tables 
+* (both IPv4 and IPv6), IP addresses, link parame- ters, neighbor
+* setups, queueing disciplines, traffic classes and packet 
+* classifiers (see rtnetlink (7)). This socket type is very similar
+* to the linux and BSD "packet" sockets.
+*
+* Here is a summary of the semantics of this class:
+* - Bind: Bind uses only the protocol and device fields of the 
+*       NetlinkSocketAddress.
+*
+* - Send: send the input packet to the underlying kernel space
+*       with its own address. The socket must  be bound.
+*
+* - Recv: receive packet from the kernel space.
+*
+* - Accept: not allowed
+* - Connect: not allowed
+*/
+class NetlinkSocket : public Socket
+{
+public:
+  static TypeId GetTypeId (void);
+
+  NetlinkSocket ();
+  virtual ~NetlinkSocket ();
+
+  void SetNode (Ptr<Node> node);
+
+  virtual enum SocketErrno GetErrno (void) const;
+  virtual Ptr<Node> GetNode (void) const;
+  virtual int Bind (void);
+  virtual int Bind (const Address & address);
+  virtual int Close (void);
+  virtual int ShutdownSend (void);
+  virtual int ShutdownRecv (void);
+  virtual int Connect(const Address &address);
+  virtual int Listen(void);
+  virtual uint32_t GetTxAvailable (void) const;
+  virtual int Send (Ptr<Packet> p, uint32_t flags);
+  virtual int SendTo(Ptr<Packet> p, uint32_t flags, const Address &toAddress);
+  virtual uint32_t GetRxAvailable (void) const;
+  virtual Ptr<Packet> Recv (uint32_t maxSize, uint32_t flags);
+  virtual Ptr<Packet> RecvFrom (uint32_t maxSize, uint32_t flags, 
+    Address &fromAddress);
+  virtual int GetSockName (Address &address) const; 
+
+  uint32_t GetSrcPid(void) const;
+  uint32_t GetSrcGroups(void)const;
+  uint32_t GetDstPid(void) const;
+  uint32_t GetDstGroups(void)const;
+  static int32_t NotifyIfAddrMessage(Ipv6Interface* interface, Ipv6Address addr, int cmd);
+
+private:
+  int DoBind (const NetlinkSocketAddress &address);
+  virtual void DoDispose (void);
+  void ForwardUp (Ptr<Packet> p, NetlinkSocketAddress &address);
+
+
+
+  /**
+ * the functions below were for kernel parsing netlink message,set private here
+ * when netlink msg sent to kernel through netlink socket, it was parsed in kernel
+ * space, then, kernel add/del its route/interface/link table or dump all information
+ * to user space
+ */
+
+  int32_t HandleMessage (const NetlinkMessage&nlmsg);
+  /**
+  * when kernel find the message truncated or user need an ACK response,
+  * it send ACK back to user space, with the error code(0 for ACK, > 0 for error).
+  */
+  void SendAckMessage (const NetlinkMessage&nlmsg, int32_t errorcode);
+
+  /**
+  * \brief unicast an message to user
+  * \param nlmsg the netlink message to transmit
+  * \param pid the netlink pid of destination socket
+  * \param nonbloack always true
+  */
+  int32_t SendMessageUnicast (const MultipartNetlinkMessage&nlmsg, 
+  uint32_t pid, int32_t nonblock);
+  /**
+  * \brief spread message to netlink group user
+  * \param nlmsg the netlink message to transmit
+  * \param pid the netlink pid of the kernel, always 0
+  * \param group multicast group id
+  */
+  static int32_t SendMessageBroadcast (const MultipartNetlinkMessage&nlmsg, 
+                                       uint32_t pid, uint32_t group, Ptr<Node> node);
+
+  /**
+  * these functions below are for NETLINK_ROUTE protocol, it handle the netlink 
+  * message like linux kernel work.  this implementation follows the kernel code 
+  * linux/rtnetlink.c, focus on "interface address, interface info and route entry",
+  * now we will only simply support three types operations of  NETLINK_ROUTE 
+  * protocol
+  */
+  
+  /**
+  * \returns 0 if messge not processed, < 0 for success or an error.
+  * this function would call dumping/doing functions to  
+  */
+  int32_t HandleNetlinkRouteMessage (const NetlinkMessage&nlmsg);
+  
+  /**
+  * \returns 0 if dumping operation is OK, < 0 for an error.
+  */ 
+  int32_t DumpNetlinkRouteMessage (const NetlinkMessage&nlmsg, 
+  uint16_t type, uint8_t family);
+  MultipartNetlinkMessage BuildInterfaceAddressDumpMessage (
+    uint32_t pid, uint32_t seq, uint8_t family);
+  MultipartNetlinkMessage BuildInterfaceInfoDumpMessage (
+    uint32_t pid, uint32_t seq, uint8_t family);
+  MultipartNetlinkMessage BuildRouteDumpMessage (
+    uint32_t pid, uint32_t seq, uint8_t family);
+
+  /**
+  * \returns 0 if doing operation(ADD/DEL/GET) is OK, < 0 for an error.
+  */
+  int32_t DoNetlinkRouteMessage (const NetlinkMessage&nlmsg,
+    uint16_t type, uint8_t family);
+  int32_t DoInterfaceAddressMessage (const NetlinkMessage&nlmsg, 
+    uint16_t type, uint8_t family);
+  int32_t DoInterfaceInfoMessage (const NetlinkMessage&nlmsg, 
+    uint16_t type, uint8_t family);
+  int32_t DoRouteMessage (const NetlinkMessage&nlmsg, 
+    uint16_t type, uint8_t family);
+
+  int ErrnoToSimuErrno (void);
+
+  Ptr<Node> m_node;
+  enum SocketErrno m_errno;
+  bool m_shutdownSend;
+  bool m_shutdownRecv;
+
+  std::queue<Ptr<Packet> > m_dataReceiveQueue;
+  uint32_t m_rxAvailable;
+  TracedCallback<Ptr<const Packet> > m_dropTrace;
+  // Socket options (attributes)
+  uint32_t m_rcvBufSize;
+
+  uint32_t m_srcPid;
+  uint32_t m_srcGroups;
+  uint32_t m_dstPid;
+  uint32_t m_dstGroups;
+  Callback<void, Ipv4Address,uint8_t,uint8_t,uint8_t,uint32_t> m_icmpCallback;
+};
+
+}//namespace ns3
+
+#endif /* NETLINK_SOCKET_H */
+
+
--- a/src/node/node.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/node/node.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -30,6 +30,7 @@
+#include "ns3/socket.h"
@@ -251,6 +252,10 @@
+  SocketRecvIfTag tag;
+  tag.SetRecvIf (device->GetIfIndex());
+  packet->AddByteTag (tag);
+
--- a/src/node/socket.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/node/socket.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -428,4 +428,58 @@
+
+SocketRecvIfTag::SocketRecvIfTag ()  
+{
+}
+
+void 
+SocketRecvIfTag::SetRecvIf (uint32_t ifindex)
+{
+  m_ifindex = ifindex;
+}
+
+uint32_t 
+SocketRecvIfTag::GetRecvIf (void) const
+{
+  return m_ifindex;
+}
+
+
+TypeId
+SocketRecvIfTag::GetTypeId (void)
+{
+  static TypeId tid = TypeId ("ns3::SocketRecvIfTag")
+    .SetParent<Tag> ()
+    .AddConstructor<SocketRecvIfTag> ()
+    ;
+  return tid;
+}
+TypeId
+SocketRecvIfTag::GetInstanceTypeId (void) const
+{
+  return GetTypeId ();
+}
+
+uint32_t 
+SocketRecvIfTag::GetSerializedSize (void) const
+{ 
+  return sizeof(uint32_t);
+}
+void 
+SocketRecvIfTag::Serialize (TagBuffer i) const
+{ 
+  i.WriteU32 (m_ifindex);
+}
+void 
+SocketRecvIfTag::Deserialize (TagBuffer i)
+{ 
+  m_ifindex = i.ReadU32 ();
+}
+void
+SocketRecvIfTag::Print (std::ostream &os) const
+{
+  os << "RecvIf=" << (uint32_t) m_ifindex;
+}
+
--- a/src/node/socket.h	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/node/socket.h	Thu Oct 01 23:37:18 2009 +0900
@@ -79,6 +79,8 @@
+    ERROR_NODEV,
+    ERROR_ADDRNOTAVAIL,
@@ -579,6 +581,25 @@
+class SocketRecvIfTag : public Tag
+{
+public:
+  SocketRecvIfTag ();
+  void SetRecvIf (uint32_t ifindex);
+  uint32_t GetRecvIf (void) const;
+
+  static TypeId GetTypeId (void);  
+  virtual TypeId GetInstanceTypeId (void) const;
+  virtual uint32_t GetSerializedSize (void) const;
+  virtual void Serialize (TagBuffer i) const;
+  virtual void Deserialize (TagBuffer i);
+  virtual void Print (std::ostream &os) const;
+
+private:
+  uint8_t m_ifindex;
+};
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/tcp6-socket-factory.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,38 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007-2008 Louis Pasteur University
+ *
+ * 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: David Gross <gdavid.devel@gmail.com>
+ */
+
+#include "tcp6-socket-factory.h"
+#include "ns3/uinteger.h"
+#include "ns3/double.h"
+
+namespace ns3 {
+
+  NS_OBJECT_ENSURE_REGISTERED (Tcp6SocketFactory);
+
+  TypeId Tcp6SocketFactory::GetTypeId ()
+  {
+    static TypeId tid = TypeId ("ns3::Tcp6SocketFactory")
+      .SetParent<SocketFactory> ()
+      ;
+    return tid;
+  }
+
+} /* namespace ns3 */
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/node/tcp6-socket-factory.h	Thu Oct 01 23:37:18 2009 +0900
@@ -0,0 +1,66 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2007-2008 Louis Pasteur University
+ *
+ * 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: David Gross <gdavid.devel@gmail.com>
+ */
+
+#ifndef TCP6_SOCKET_FACTORY_H
+#define TCP6_SOCKET_FACTORY_H
+
+#include "socket-factory.h"
+
+namespace ns3 {
+
+  class Socket;
+
+  /**
+   * \class Tcp6SocketFactory
+   * \brief API to create TCPv6 socket instances 
+   *
+   * This abstract class defines the API for TCPv6 sockets.
+   * This class also holds the global default variables used to
+   * initialize newly created sockets, such as values that are
+   * set through the sysctl or proc interfaces in Linux.
+
+   * All TCPv6 implementations must provide an implementation of CreateSocket
+   * below, and should make use of the default values configured below.
+   * 
+   * \see Tcp6SocketFactoryImpl
+   *
+   */
+  class Tcp6SocketFactory : public SocketFactory
+  {
+    public:
+      /**
+       * \brief Interface ID.
+       * \return type identificator
+       */
+      static TypeId GetTypeId ();
+
+      /**
+       * \brief Create a TCPv6 socket.
+       * \return a pointer on a socket
+       * API for creating socket instances; must be implemented by TCPv6 implementation.
+       */
+      virtual Ptr<Socket> CreateSocket () = 0;
+
+  };
+
+} /* namespace ns3 */
+
+#endif /* TCP6_SOCKET_FACTORY_H */
+
--- a/src/node/wscript	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/node/wscript	Thu Oct 01 23:37:18 2009 +0900
@@ -45,6 +45,14 @@
+        'netlink-socket.cc',
+        'netlink-socket-address.cc',
+        'netlink-socket-factory.cc',
+        'netlink-attribute.cc',
+        'netlink-message.cc', 
+        'netlink-message-route.cc',       
+        'netlink-ipv6-routing-table.cc', 
+        'tcp6-socket-factory.cc',
@@ -91,4 +99,12 @@
+        'netlink-socket.h',
+        'netlink-socket-address.h',
+        'netlink-socket-factory.h',
+        'netlink-attribute.h',
+        'netlink-message.h', 
+        'netlink-message-route.h', 
+        'netlink-ipv6-routing-table.h', 
+        'tcp6-socket-factory.h',
--- a/src/process-manager/libc-simu.c	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/libc-simu.c	Thu Oct 01 23:37:18 2009 +0900
@@ -48,11 +48,11 @@
-  libc.newlocale_fn = newlocale;
-  libc.uselocale_fn = uselocale;
+//  libc.newlocale_fn = newlocale;
+//  libc.uselocale_fn = uselocale;
-  libc.wctype_l_fn = wctype_l;
+//  libc.wctype_l_fn = wctype_l;
--- a/src/process-manager/libc.c	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/libc.c	Thu Oct 01 23:37:18 2009 +0900
@@ -89,6 +89,7 @@
+#if 0
@@ -99,6 +100,7 @@
+#endif
@@ -107,11 +109,13 @@
+#if 0
+#endif
@@ -128,10 +132,12 @@
+#if 0
+#endif
--- a/src/process-manager/libc.h	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/libc.h	Thu Oct 01 23:37:18 2009 +0900
@@ -2,6 +2,7 @@
+#include <stdio.h>
@@ -47,11 +48,11 @@
-  __locale_t (*newlocale_fn) (int category_mask, const char *locale, __locale_t base);
-  __locale_t (*uselocale_fn) (__locale_t __dataset);
+//  __locale_t (*newlocale_fn) (int category_mask, const char *locale, __locale_t base);
+//  __locale_t (*uselocale_fn) (__locale_t __dataset);
-  wctype_t (*wctype_l_fn) (__const char *__property, __locale_t __locale);
+//  wctype_t (*wctype_l_fn) (__const char *__property, __locale_t __locale);
@@ -86,8 +87,8 @@
-  const char *(*strchr_fn) (const char *s, int c);
-  const char *(*strrchr_fn) (const char *s, int c);
+  char *(*strchr_fn) (const char *s, int c);
+  char *(*strrchr_fn) (const char *s, int c);
--- a/src/process-manager/simu-fd.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/simu-fd.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -30,6 +30,7 @@
+#include "ns3/ipv6-raw-socket-impl.h"
@@ -476,26 +477,73 @@
-  switch (type) {
-  case SOCK_DGRAM: {
-    TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
-    Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
-    sock = factory->CreateSocket ();
-    socket = Create<UnixDatagramSocketFd> (sock);
-  } break;
-  case SOCK_RAW: {
-    TypeId tid = TypeId::LookupByName ("ns3::Ipv4RawSocketFactory");
-    Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
-    sock = factory->CreateSocket ();
-    sock->SetAttribute ("Protocol", UintegerValue (protocol));
-    socket = Create<UnixDatagramSocketFd> (sock);
-  } break;
-  case SOCK_STREAM: {
-    TypeId tid = TypeId::LookupByName ("ns3::TcpSocketFactory");
-    Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
-    sock = factory->CreateSocket ();
-    socket = Create<UnixStreamSocketFd> (sock);
-  } break;
+  if (domain == PF_INET)
+    {
+      switch (type) {
+      case SOCK_DGRAM: {
+        TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
+        Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
+        sock = factory->CreateSocket ();
+        socket = Create<UnixDatagramSocketFd> (sock);
+        } break;
+      case SOCK_RAW: {
+        TypeId tid = TypeId::LookupByName ("ns3::Ipv4RawSocketFactory");
+        Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
+        sock = factory->CreateSocket ();
+        sock->SetAttribute ("Protocol", UintegerValue (protocol));
+        socket = Create<UnixDatagramSocketFd> (sock);
+        } break;
+      case SOCK_STREAM: {
+        TypeId tid = TypeId::LookupByName ("ns3::TcpSocketFactory");
+        Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
+        sock = factory->CreateSocket ();
+        socket = Create<UnixStreamSocketFd> (sock);
+        } break;
+      }
+    }
+  else if (domain == PF_INET6)
+    {
+      switch (type) {
+      case SOCK_DGRAM: {
+        TypeId tid = TypeId::LookupByName ("ns3::Udp6SocketFactory");
+        Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
+        sock = factory->CreateSocket ();
+        socket = Create<UnixDatagramSocketFd> (sock);
+        } break;
+      case SOCK_RAW: {
+        TypeId tid = TypeId::LookupByName ("ns3::Ipv6RawSocketFactory");
+        Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
+        sock = factory->CreateSocket ();
+        sock->Bind();
+        sock->SetAttribute ("Protocol", UintegerValue (protocol));
+        socket = Create<UnixDatagramSocketFd> (sock);
+        } break;
+      case SOCK_STREAM: {
+        TypeId tid = TypeId::LookupByName ("ns3::Tcp6SocketFactory");
+        Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
+        sock = factory->CreateSocket ();
+        socket = Create<UnixStreamSocketFd> (sock);
+        } break;
+      }
+    }
+  else if (domain == PF_NETLINK)
+    {
+      if (type != SOCK_DGRAM && type != SOCK_RAW)
+        {
+          current->err = ESOCKTNOSUPPORT;
+          return -1;
+        }
+      /*for now we only support NETLINK_ROUTE*/
+      if (protocol != NETLINK_ROUTE)
+        {
+          current->err = EPROTONOSUPPORT;
+          return -1;
+        }
+      
+      TypeId tid= TypeId::LookupByName("ns3::NetlinkSocketFactory");
+      Ptr<SocketFactory> factory = manager->GetObject<SocketFactory> (tid);
+      sock = factory->CreateSocket ();
+      socket = Create<UnixDatagramSocketFd> (sock);
--- a/src/process-manager/simu-stdio.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/simu-stdio.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -298,7 +298,10 @@
-  int retval = ::vasprintf (&str, format, ap);
+  std::stringstream ss;
+  ss <<  "Node" << UtilsGetNodeId() << ": " << format;
+
+  int retval = ::vasprintf (&str, ss.str().c_str(), ap);
--- a/src/process-manager/unix-datagram-socket-fd.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/unix-datagram-socket-fd.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -6,7 +6,11 @@
+#include "ns3/node.h"
+#include "ns3/ipv6-raw-socket-impl.h"
+#include "ns3/ipv6.h"
+//#include "ns3/udp6-socket-impl.h"
@@ -130,7 +134,7 @@
-      msg->msg_controllen = 0;
+      //      msg->msg_controllen = 0;
@@ -151,6 +155,31 @@
+
+  if(msg->msg_controllen > 0){
+    Cmsg cmsg = Cmsg (msg);
+    if (IsRecvPktInfo ())
+      {
+        struct in6_pktinfo pkt;
+      
+        SocketRecvIfTag tag;
+        bool found;
+        found = packet->FindFirstMatchingByteTag (tag);
+        NS_ASSERT (found);
+
+        Ptr<Node> node = current->process->manager->GetObject<Node> ();
+        Ptr<Ipv6> ipv6 = node->GetObject<Ipv6> ();
+        pkt.ipi6_ifindex = ipv6->GetInterfaceForDevice (node->GetDevice(tag.GetRecvIf ()));
+        memcpy(&pkt.ipi6_addr, msg->msg_name, sizeof(pkt.ipi6_addr));
+        cmsg.Add (SOL_IPV6, IPV6_PKTINFO, sizeof (struct in6_pktinfo), (const uint8_t*)&pkt);
+
+  Ipv6Header hdr = Ipv6Header();
+  packet->RemoveHeader (hdr);
+      }
+    cmsg.Finish ();
+  }
+
+
@@ -162,7 +191,42 @@
+  uint32_t old_ifindex = 0;
+  // parse cmsg
+  Cmsg cmsg = Cmsg ((struct msghdr *)msg);
+  int level, type, len;
+  uint8_t *data = NULL;
+  if (cmsg.GetNext (&level, &type, &len, &data) == 0)
+    {
+      switch (type){
+      case IPV6_PKTINFO:{
+        struct in6_pktinfo *pktinfo = (struct in6_pktinfo *)data;
+        if (len != sizeof(struct in6_pktinfo))
+          break;
+
+        //        if(m_socket.GetTypeId().IsChildOf (Ipv6RawSocketImpl::GetTypeId ())) 
+        if(typeid(* PeekPointer(m_socket)) == typeid(Ipv6RawSocketImpl)) 
+          {
+            NS_LOG_INFO("sendmsg: set ifindex to " << pktinfo->ipi6_ifindex);
+            old_ifindex = (dynamic_cast<Ipv6RawSocketImpl *>(PeekPointer(m_socket)))->GetIfIndex();
+            (dynamic_cast<Ipv6RawSocketImpl *>(PeekPointer(m_socket)))->SetIfIndex(pktinfo->ipi6_ifindex);
+          }
+#ifdef FIXME
+        else if(typeid(* PeekPointer(m_socket)) == typeid(Udp6SocketImpl)) 
+          {
+            NS_LOG_INFO("sendmsg: set ifindex to " << pktinfo->ipi6_ifindex);
+            old_ifindex = (dynamic_cast<Udp6SocketImpl *>(PeekPointer(m_socket)))->GetIfIndex();
+            (dynamic_cast<Udp6SocketImpl *>(PeekPointer(m_socket)))->SetIfIndex(pktinfo->ipi6_ifindex);
+          }
+#endif
+      }break;
+      default: {
+        NS_LOG_INFO ("cmsg: Currently not supported");
+      }break;
+      }
+    }
+  cmsg.Finish ();
@@ -181,6 +245,18 @@
+
+      if(typeid(* PeekPointer(m_socket)) == typeid(Ipv6RawSocketImpl)) 
+        {
+          (dynamic_cast<Ipv6RawSocketImpl *>(PeekPointer(m_socket)))->SetIfIndex(old_ifindex);
+        }
+#ifdef FIXME
+      else if(typeid(* PeekPointer(m_socket)) == typeid(Udp6SocketImpl)) 
+        {
+          (dynamic_cast<Udp6SocketImpl *>(PeekPointer(m_socket)))->SetIfIndex(old_ifindex);
+        }
+#endif
+
--- a/src/process-manager/unix-socket-fd.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/unix-socket-fd.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -9,11 +9,20 @@
+#include "ns3/netlink-socket-address.h"
+#include "ns3/netlink-socket.h"
+#include "ns3/ipv6-address.h"
+#include "ns3/inet6-socket-address.h"
+#include "ns3/pointer.h"
+#include "ns3/ipv6-raw-socket-impl.h"
+#include <netinet/icmp6.h> // need ICMP6_FILTER
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
@@ -76,6 +85,10 @@
+  case Socket::ERROR_NODEV:
+    return ENODEV;
+  case Socket::ERROR_ADDRNOTAVAIL:
+    return EADDRNOTAVAIL;
@@ -258,6 +271,84 @@
+  case SOL_IPV6:
+    switch (optname) {
+    case IPV6_RECVPKTINFO: {
+      if (optlen != sizeof (int))
+	{
+	  current->err = EINVAL;
+	  return -1;
+	}
+      int *v = (int*)optval;
+      m_recvpktinfo = *v;
+    } break;
+    case IPV6_CHECKSUM: {
+      if (optlen != sizeof (int))
+	{
+	  current->err = EINVAL;
+	  return -1;
+	}
+      int *v = (int*)optval;
+      m_sockchecksum = *v;
+    } break;
+    case IPV6_MULTICAST_LOOP: {
+      if (optlen != sizeof (int))
+	{
+	  current->err = EINVAL;
+	  return -1;
+	}
+      int *v = (int*)optval;
+      m_multicastloop = *v;
+    } break;
+    case IPV6_UNICAST_HOPS: {
+      if (optlen != sizeof (int))
+	{
+	  current->err = EINVAL;
+	  return -1;
+	}
+      int *v = (int*)optval;
+      m_unicasthops = *v;
+    } break;
+    case IPV6_MULTICAST_HOPS: {
+      if (optlen != sizeof (int))
+	{
+	  current->err = EINVAL;
+	  return -1;
+	}
+      int *v = (int*)optval;
+      m_multicasthops = *v;
+    } break;
+    case IPV6_RECVHOPLIMIT: {
+      if (optlen != sizeof (int))
+	{
+	  current->err = EINVAL;
+	  return -1;
+	}
+      int *v = (int*)optval;
+      m_recvhoplimit = *v;
+    } break;
+    } 
+    break;
+  case SOL_ICMPV6:
+    switch (optname) {
+    case ICMP6_FILTER: {
+      if (optlen != sizeof (struct icmp6_filter))
+        {
+          current->err = EINVAL;
+          return -1;
+        }
+      struct icmp6_filter *v = (struct icmp6_filter*)optval;
+      if(v){
+        (dynamic_cast<Ipv6RawSocketImpl *>(PeekPointer(m_socket)))->SetIcmp6Filter(v);
+      }
+    } break;
+    }
+    break;
+  default:{
+    std::cout << "Unsupported sockopt\n";
+      current->err = ENOPROTOOPT;
+    return -1;
+  } break;
@@ -420,8 +511,28 @@
-  NS_ASSERT (false);
-  return Address ();
+  else if (my_addr->sa_family == AF_NETLINK )
+    {
+      const struct sockaddr_nl *addr = (const struct sockaddr_nl *)my_addr;
+      //user space netlink socket has a nozero process id
+      uint32_t pid = addr->nl_pid ? addr->nl_pid : getpid();
+      NetlinkSocketAddress nladdress = NetlinkSocketAddress(pid, addr->nl_groups);
+      return nladdress;
+    }
+  else if (my_addr->sa_family == AF_INET6)
+    {
+      const struct sockaddr_in6 *addr = (const struct sockaddr_in6 *)my_addr;
+      Ipv6Address ipv6;
+      ipv6.Set ((uint8_t *)addr->sin6_addr.s6_addr);
+      uint16_t port = ntohs (addr->sin6_port);
+      Inet6SocketAddress inet = Inet6SocketAddress (ipv6, port);
+      return inet;
+    }
+  else
+    {
+      NS_ASSERT (false);
+      return Address ();
+    }
@@ -444,6 +555,30 @@
+  else if (NetlinkSocketAddress::IsMatchingType(nsaddr))
+    {
+      NetlinkSocketAddress ns_nladdr = NetlinkSocketAddress::ConvertFrom(nsaddr);
+      NS_ASSERT (*addrlen >= sizeof (struct sockaddr_nl));
+      struct sockaddr_nl *nl_addr = (struct sockaddr_nl *)addr;
+      nl_addr->nl_family = AF_NETLINK;
+      nl_addr->nl_pid = ns_nladdr.GetProcessID();
+      nl_addr->nl_groups = ns_nladdr.GetGroupsMask();
+      *addrlen = sizeof(struct sockaddr_nl);
+      return 0;
+    }
+  else if (Inet6SocketAddress::IsMatchingType(nsaddr))
+    {
+      Inet6SocketAddress ns_inet6addr = Inet6SocketAddress::ConvertFrom(nsaddr);
+      if (*addrlen < sizeof (struct sockaddr_in6))
+	{
+	  return -1;
+	}
+      struct sockaddr_in6 *inet6_addr = (struct sockaddr_in6 *)addr;
+      inet6_addr->sin6_family = AF_INET6;
+      inet6_addr->sin6_port = htons (ns_inet6addr.GetPort ());
+      ns_inet6addr.GetIpv6 ().GetBytes (inet6_addr->sin6_addr.s6_addr);
+      *addrlen = sizeof(struct sockaddr_in6);
+    }
@@ -490,6 +625,11 @@
+bool 
+UnixSocketFd::IsRecvPktInfo (void) const
+{
+  return m_recvpktinfo == 1;
+}
--- a/src/process-manager/unix-socket-fd.h	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/unix-socket-fd.h	Thu Oct 01 23:37:18 2009 +0900
@@ -49,6 +49,7 @@
+  bool IsRecvPktInfo (void) const;
@@ -60,6 +61,12 @@
+  int m_recvpktinfo;
+  int m_sockchecksum;
+  int m_multicastloop;
+  int m_unicasthops;
+  int m_multicasthops;
+  int m_recvhoplimit;
--- a/src/process-manager/utils.cc	Mon Sep 07 15:45:12 2009 +0200
+++ b/src/process-manager/utils.cc	Thu Oct 01 23:37:18 2009 +0900
@@ -52,7 +52,8 @@
-      if (errno != ENOENT)
+      ::perror("simu path");
+      if (errno == ENOENT)
--- a/wscript	Mon Sep 07 15:45:12 2009 +0200
+++ b/wscript	Thu Oct 01 23:37:18 2009 +0900
@@ -430,7 +430,7 @@
-def create_ns3_program(bld, name, dependencies=('simulator',)):
+def create_ns3_program(bld, name, dependencies=('simulator', )):
@@ -458,6 +458,12 @@
+#            obj.add_objects.append('ns3-visualizer')
+#            modules = bld.env['NS3_ENABLED_MODULES']
+#            modules.append('ns3-visualizer')
+#            obj.uselib_local = 'ns3-visualizer'
+#            obj.add_objects = 'ns3-visualizer'
+#            obj.uselib = 'png'
@@ -465,6 +471,10 @@
+#            obj.add_objects += ' visualizer'
+#            obj.uselib_local += ' visualizer'
+#            obj.add_objects += ' visualizer'
+#            obj.uselib_local += ' visualizer'
@@ -550,6 +560,9 @@
+    lib.add_objects.append('ns3-visualizer')
+    lib.uselib_local.append('ns3-visualizer')
+
--- a/wutils.py	Mon Sep 07 15:45:12 2009 +0200
+++ b/wutils.py	Thu Oct 01 23:37:18 2009 +0900
@@ -107,10 +107,13 @@
+    pyvizdir = bld.path.find_dir('src/contrib').abspath()
+    python_path_add = [pymoddir, pyvizdir]
+
-        proc_env['PYTHONPATH'] = os.pathsep.join([pymoddir] + [proc_env['PYTHONPATH']])
+        proc_env['PYTHONPATH'] = os.pathsep.join(python_path_add + [proc_env['PYTHONPATH']])
-        proc_env['PYTHONPATH'] = pymoddir
+        proc_env['PYTHONPATH'] = os.pathsep.join(python_path_add)
author	tazaki@vmlinux-zak
date	Thu Oct 01 23:37:18 2009 +0900 (2 years ago)
parents	86acc8e9b3e6
children	bd7211da3ecd
files	.hgignore bindings/python/ns3_module_contrib.py bindings/python/wscript src/contrib/wscript src/helper/internet-stack-helper.cc src/helper/ipv6-interface-container.cc src/helper/netlink-socket-helper.cc src/helper/netlink-socket-helper.h src/helper/node-container.cc src/helper/node-container.h src/helper/wscript src/internet-stack/ipv6-l3-protocol.cc src/internet-stack/ipv6-l3-protocol.h src/internet-stack/ipv6-raw-socket-impl.cc src/internet-stack/ipv6-raw-socket-impl.h src/internet-stack/tcp6-l4-protocol.cc src/internet-stack/tcp6-l4-protocol.h src/internet-stack/tcp6-socket-factory-impl.cc src/internet-stack/tcp6-socket-factory-impl.h src/internet-stack/tcp6-socket-impl.cc src/internet-stack/tcp6-socket-impl.h src/internet-stack/wscript src/mobility/oneway-mobility-model.cc src/mobility/oneway-mobility-model.h src/mobility/wscript src/node/ipv6-address.cc src/node/ipv6-address.h src/node/netlink-attribute.cc src/node/netlink-attribute.h src/node/netlink-ipv6-routing-table.cc src/node/netlink-ipv6-routing-table.h src/node/netlink-message-route.cc src/node/netlink-message-route.h src/node/netlink-message.cc src/node/netlink-message.h src/node/netlink-socket-address.cc src/node/netlink-socket-address.h src/node/netlink-socket-factory.cc src/node/netlink-socket-factory.h src/node/netlink-socket-test.cc src/node/netlink-socket.cc src/node/netlink-socket.h src/node/node.cc src/node/socket.cc src/node/socket.h src/node/tcp6-socket-factory.cc src/node/tcp6-socket-factory.h src/node/wscript src/process-manager/libc-simu.c src/process-manager/libc.c src/process-manager/libc.h src/process-manager/simu-fd.cc src/process-manager/simu-stdio.cc src/process-manager/unix-datagram-socket-fd.cc src/process-manager/unix-socket-fd.cc src/process-manager/unix-socket-fd.h src/process-manager/utils.cc wscript wutils.py