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

 /*

  * 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

  *

  * based on earlier integration work by Tom Henderson and Sam Jansen.

  * 2008 Florian Westphal <fw@strlen.de>

  */

 #include "ns3/assert.h"

 #include "ns3/log.h"

 #include "ns3/packet.h"

 #include "ns3/node.h"

 #include "ns3/ipv4-route.h"

 #include "ns3/object-vector.h"

 #include "ns3/string.h"

 #include "tcp-header.h"

 #include "ipv4-end-point-demux.h"

 #include "ipv4-end-point.h"

 #include "ipv4-l3-protocol.h"

 #include "nsc-tcp-l4-protocol.h"

 #include "nsc-tcp-socket-factory-impl.h"

 #include "tcp-typedefs.h"

 #include <vector>

 #include <sstream>

 #include <dlfcn.h>

 #include <iomanip>

 #include <netinet/in.h>

 #include <arpa/inet.h>

 NS_LOG_COMPONENT_DEFINE ("NscTcpL4Protocol");

 namespace ns3 {

 NS_OBJECT_ENSURE_REGISTERED (NscTcpL4Protocol);

 /* see http://www.iana.org/assignments/protocol-numbers */

 const uint8_t NscTcpL4Protocol::PROT_NUMBER = 6;

 ObjectFactory

 NscTcpL4Protocol::GetDefaultRttEstimatorFactory (void)

 {

   ObjectFactory factory;

   factory.SetTypeId (RttMeanDeviation::GetTypeId ());

   return factory;

 }

 TypeId 

 NscTcpL4Protocol::GetTypeId (void)

 {

   static TypeId tid = TypeId ("ns3::NscTcpL4Protocol")

     .SetParent<Ipv4L4Protocol> ()

     .AddConstructor<NscTcpL4Protocol>()

     .AddAttribute ("RttEstimatorFactory",

                    "How RttEstimator objects are created.",

                    ObjectFactoryValue (GetDefaultRttEstimatorFactory ()),

                    MakeObjectFactoryAccessor (&NscTcpL4Protocol::m_rttFactory),

                    MakeObjectFactoryChecker ())

     .AddAttribute ("SocketList", "The list of sockets associated to this protocol.",

                    ObjectVectorValue (),

                    MakeObjectVectorAccessor (&NscTcpL4Protocol::m_sockets),

                    MakeObjectVectorChecker<NscTcpSocketImpl> ())

     .AddAttribute ("Library",

                    "Set the linux library to be used to create the stack",

                    TypeId::ATTR_GET|TypeId::ATTR_CONSTRUCT,

                    StringValue("liblinux2.6.26.so"),

                    MakeStringAccessor (&NscTcpL4Protocol::GetNscLibrary,&NscTcpL4Protocol::SetNscLibrary),

                    MakeStringChecker ())

     ;

   return tid;

 }

 NscTcpL4Protocol::NscTcpL4Protocol ()

   : m_endPoints (new Ipv4EndPointDemux ())

 {

   NS_LOG_LOGIC("Made a NscTcpL4Protocol "<<this);

 }

 void

 NscTcpL4Protocol::SetNscLibrary(const std::string &soname)

 {    

   if (soname!="")

     {

       m_nscLibrary = soname;

     }

 }

 std::string 

 NscTcpL4Protocol::GetNscLibrary () const

 {

   return m_nscLibrary;

 }

 void

 NscTcpL4Protocol::SetNode (Ptr<Node> node)

 {

   m_node = node;

   m_node->SetNscLibrary (m_nscLibrary);

   m_node->RegisterNscWakeupCallback (MakeCallback (&NscTcpL4Protocol::Wakeup , this));

 }

 void

 NscTcpL4Protocol::NotifyNewAggregate ()

 { 

   if (m_node == 0)

     {

       Ptr<Node>node = this->GetObject<Node> ();

       if (node != 0)

         {

           Ptr<Ipv4L3Protocol> ipv4 = this->GetObject<Ipv4L3Protocol> ();

           if (ipv4 != 0)

             {

               this->SetNode (node);

               ipv4->Insert (this);

               Ptr<NscTcpSocketFactoryImpl> tcpFactory = CreateObject<NscTcpSocketFactoryImpl> ();

               tcpFactory->SetTcp (this);

               node->AggregateObject (tcpFactory);

             }

         }

     }

   Object::NotifyNewAggregate ();

 }

 int 

 NscTcpL4Protocol::GetProtocolNumber (void) const

 {

   return PROT_NUMBER;

 }

 int 

 NscTcpL4Protocol::GetVersion (void) const

 {

   return 2;

 }

 void

 NscTcpL4Protocol::DoDispose (void)

 {

   NS_LOG_FUNCTION (this);

   for (std::vector<Ptr<NscTcpSocketImpl> >::iterator i = m_sockets.begin (); i != m_sockets.end (); i++)

     {

       *i = 0;

     }

   m_sockets.clear ();

   if (m_endPoints != 0)

     {

       delete m_endPoints;

       m_endPoints = 0;

     }

   m_node = 0;

   Ipv4L4Protocol::DoDispose ();

 }

 Ptr<Socket>

 NscTcpL4Protocol::CreateSocket (void)

 {

   NS_LOG_FUNCTION (this);

   Ptr<RttEstimator> rtt = m_rttFactory.Create<RttEstimator> ();

   Ptr<NscTcpSocketImpl> socket = CreateObject<NscTcpSocketImpl> ();

   socket->SetNode (m_node);

   socket->SetTcp (this);

   socket->SetRtt (rtt);

   m_sockets.push_back (socket);

   return socket;

 }

 Ipv4EndPoint *

 NscTcpL4Protocol::Allocate (void)

 {

   NS_LOG_FUNCTION (this);

   return m_endPoints->Allocate ();

 }

 Ipv4EndPoint *

 NscTcpL4Protocol::Allocate (Ipv4Address address)

 {

   NS_LOG_FUNCTION (this << address);

   return m_endPoints->Allocate (address);

 }

 Ipv4EndPoint *

 NscTcpL4Protocol::Allocate (uint16_t port)

 {

   NS_LOG_FUNCTION (this << port);

   return m_endPoints->Allocate (port);

 }

 Ipv4EndPoint *

 NscTcpL4Protocol::Allocate (Ipv4Address address, uint16_t port)

 {

   NS_LOG_FUNCTION (this << address << port);

   return m_endPoints->Allocate (address, port);

 }

 Ipv4EndPoint *

 NscTcpL4Protocol::Allocate (Ipv4Address localAddress, uint16_t localPort,

                          Ipv4Address peerAddress, uint16_t peerPort)

 {

   NS_LOG_FUNCTION (this << localAddress << localPort << peerAddress << peerPort);

   return m_endPoints->Allocate (localAddress, localPort,

                                 peerAddress, peerPort);

 }

 void 

 NscTcpL4Protocol::DeAllocate (Ipv4EndPoint *endPoint)

 {

   NS_LOG_FUNCTION (this << endPoint);

   m_endPoints->DeAllocate (endPoint);

 }

 void NscTcpL4Protocol::Wakeup()

 {

   // TODO

   // this should schedule a timer to read from all tcp sockets now... this is

   // an indication that data might be waiting on the socket

   Ipv4EndPointDemux::EndPoints endPoints = m_endPoints->GetAllEndPoints ();

   for (Ipv4EndPointDemux::EndPointsI endPoint = endPoints.begin ();

        endPoint != endPoints.end (); endPoint++) {

           // NSC HACK: (ab)use TcpSocket::ForwardUp for signalling

           (*endPoint)->ForwardUp (NULL, Ipv4Address(), 0);

   }

 }

 Ipv4L4Protocol::RxStatus

 NscTcpL4Protocol::Receive (Ptr<Packet> p,

                        Ipv4Address const &source,

                        Ipv4Address const &destination,

                        Ptr<Ipv4Interface> incomingInterface)

 { // STUB, RX happens in node/node.cc if NSC is in use.

   return Ipv4L4Protocol::RX_OK;

 }

 }; // namespace ns3