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

/*

 * Copyright 2007 University of Washington

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Authors:  Tom Henderson (tomhend@u.washington.edu)

 */

#include "ns3/log.h"

#include "ns3/assert.h"

#include "ns3/abort.h"

#include "ns3/channel.h"

#include "ns3/net-device.h"

#include "ns3/node.h"

#include "ns3/node-list.h"

#include "ns3/ipv4.h"

#include "ns3/bridge-net-device.h"

#include "ipv4-global-routing.h"

#include "global-router-interface.h"

#include <vector>

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("GlobalRouter");

// ---------------------------------------------------------------------------

//

// GlobalRoutingLinkRecord Implementation

//

// ---------------------------------------------------------------------------

GlobalRoutingLinkRecord::GlobalRoutingLinkRecord ()

  :

    m_linkId ("0.0.0.0"),

    m_linkData ("0.0.0.0"),

    m_linkType (Unknown),

    m_metric (0)

{

  NS_LOG_FUNCTION (this);

}

GlobalRoutingLinkRecord::GlobalRoutingLinkRecord (

  LinkType    linkType, 

  Ipv4Address linkId, 

  Ipv4Address linkData, 

  uint16_t    metric)

  :

    m_linkId (linkId),

    m_linkData (linkData),

    m_linkType (linkType),

    m_metric (metric)

{

  NS_LOG_FUNCTION (this << linkType << linkId << linkData << metric);

}

GlobalRoutingLinkRecord::~GlobalRoutingLinkRecord ()

{

  NS_LOG_FUNCTION (this);

}

Ipv4Address

GlobalRoutingLinkRecord::GetLinkId (void) const

{

  NS_LOG_FUNCTION (this);

  return m_linkId;

}

void

GlobalRoutingLinkRecord::SetLinkId (Ipv4Address addr)

{

  NS_LOG_FUNCTION (this << addr);

  m_linkId = addr;

}

Ipv4Address

GlobalRoutingLinkRecord::GetLinkData (void) const

{

  NS_LOG_FUNCTION (this);

  return m_linkData;

}

void

GlobalRoutingLinkRecord::SetLinkData (Ipv4Address addr)

{

  NS_LOG_FUNCTION (this << addr);

  m_linkData = addr;

}

GlobalRoutingLinkRecord::LinkType

GlobalRoutingLinkRecord::GetLinkType (void) const

{

  NS_LOG_FUNCTION (this);

  return m_linkType;

}

void

GlobalRoutingLinkRecord::SetLinkType (

  GlobalRoutingLinkRecord::LinkType linkType)

{

  NS_LOG_FUNCTION (this << linkType);

  m_linkType = linkType;

}

uint16_t

GlobalRoutingLinkRecord::GetMetric (void) const

{

  NS_LOG_FUNCTION (this);

  return m_metric;

}

void

GlobalRoutingLinkRecord::SetMetric (uint16_t metric)

{

  NS_LOG_FUNCTION (this << metric);

  m_metric = metric;

}

// ---------------------------------------------------------------------------

//

// GlobalRoutingLSA Implementation

//

// ---------------------------------------------------------------------------

GlobalRoutingLSA::GlobalRoutingLSA()

  : 

    m_lsType (GlobalRoutingLSA::Unknown),

    m_linkStateId ("0.0.0.0"),

    m_advertisingRtr ("0.0.0.0"),

    m_linkRecords (),

    m_networkLSANetworkMask ("0.0.0.0"),

    m_attachedRouters (),

    m_status (GlobalRoutingLSA::LSA_SPF_NOT_EXPLORED),

    m_node_id (0)

{

  NS_LOG_FUNCTION (this);

}

GlobalRoutingLSA::GlobalRoutingLSA (

  GlobalRoutingLSA::SPFStatus status,

  Ipv4Address linkStateId, 

  Ipv4Address advertisingRtr)

  :

    m_lsType (GlobalRoutingLSA::Unknown),

    m_linkStateId (linkStateId),

    m_advertisingRtr (advertisingRtr),

    m_linkRecords (),

    m_networkLSANetworkMask ("0.0.0.0"),

    m_attachedRouters (),

    m_status (status),

    m_node_id (0)

{

  NS_LOG_FUNCTION (this << status << linkStateId << advertisingRtr);

}

GlobalRoutingLSA::GlobalRoutingLSA (GlobalRoutingLSA& lsa)

  : m_lsType (lsa.m_lsType), m_linkStateId (lsa.m_linkStateId),

    m_advertisingRtr (lsa.m_advertisingRtr),

    m_networkLSANetworkMask (lsa.m_networkLSANetworkMask),

    m_status (lsa.m_status),

    m_node_id (lsa.m_node_id)

{

  NS_LOG_FUNCTION (this << &lsa);

  NS_ASSERT_MSG (IsEmpty (),

                 "GlobalRoutingLSA::GlobalRoutingLSA (): Non-empty LSA in constructor");

  CopyLinkRecords (lsa);

}

GlobalRoutingLSA&

GlobalRoutingLSA::operator= (const GlobalRoutingLSA& lsa)

{

  NS_LOG_FUNCTION (this << &lsa);

  m_lsType = lsa.m_lsType;

  m_linkStateId = lsa.m_linkStateId;

  m_advertisingRtr = lsa.m_advertisingRtr;

  m_networkLSANetworkMask = lsa.m_networkLSANetworkMask, 

  m_status = lsa.m_status;

  m_node_id = lsa.m_node_id;

  ClearLinkRecords ();

  CopyLinkRecords (lsa);

  return *this;

}

void

GlobalRoutingLSA::CopyLinkRecords (const GlobalRoutingLSA& lsa)

{

  NS_LOG_FUNCTION (this << &lsa);

  for (ListOfLinkRecords_t::const_iterator i = lsa.m_linkRecords.begin ();

       i != lsa.m_linkRecords.end (); 

       i++)

    {

      GlobalRoutingLinkRecord *pSrc = *i;

      GlobalRoutingLinkRecord *pDst = new GlobalRoutingLinkRecord;

      pDst->SetLinkType (pSrc->GetLinkType ());

      pDst->SetLinkId (pSrc->GetLinkId ());

      pDst->SetLinkData (pSrc->GetLinkData ());

      pDst->SetMetric (pSrc->GetMetric ());

      m_linkRecords.push_back (pDst);

      pDst = 0;

    }

  m_attachedRouters = lsa.m_attachedRouters;

}

GlobalRoutingLSA::~GlobalRoutingLSA()

{

  NS_LOG_FUNCTION (this);

  ClearLinkRecords ();

}

void

GlobalRoutingLSA::ClearLinkRecords (void)

{

  NS_LOG_FUNCTION (this);

  for ( ListOfLinkRecords_t::iterator i = m_linkRecords.begin ();

        i != m_linkRecords.end (); 

        i++)

    {

      NS_LOG_LOGIC ("Free link record");

      GlobalRoutingLinkRecord *p = *i;

      delete p;

      p = 0;

      *i = 0;

    }

  NS_LOG_LOGIC ("Clear list");

  m_linkRecords.clear ();

}

uint32_t

GlobalRoutingLSA::AddLinkRecord (GlobalRoutingLinkRecord* lr)

{

  NS_LOG_FUNCTION (this << lr);

  m_linkRecords.push_back (lr);

  return m_linkRecords.size ();

}

uint32_t

GlobalRoutingLSA::GetNLinkRecords (void) const

{

  NS_LOG_FUNCTION (this);

  return m_linkRecords.size ();

}

GlobalRoutingLinkRecord *

GlobalRoutingLSA::GetLinkRecord (uint32_t n) const

{

  NS_LOG_FUNCTION (this << n);

  uint32_t j = 0;

  for ( ListOfLinkRecords_t::const_iterator i = m_linkRecords.begin ();

        i != m_linkRecords.end (); 

        i++, j++)

    {

      if (j == n) 

        {

          return *i;

        }

    }

  NS_ASSERT_MSG (false, "GlobalRoutingLSA::GetLinkRecord (): invalid index");

  return 0;

}

bool

GlobalRoutingLSA::IsEmpty (void) const

{

  NS_LOG_FUNCTION (this);

  return m_linkRecords.size () == 0;

}

GlobalRoutingLSA::LSType

GlobalRoutingLSA::GetLSType (void) const

{

  NS_LOG_FUNCTION (this);

  return m_lsType;

}

void

GlobalRoutingLSA::SetLSType (GlobalRoutingLSA::LSType typ) 

{

  NS_LOG_FUNCTION (this << typ);

  m_lsType = typ;

}

Ipv4Address

GlobalRoutingLSA::GetLinkStateId (void) const

{

  NS_LOG_FUNCTION (this);

  return m_linkStateId;

}

void

GlobalRoutingLSA::SetLinkStateId (Ipv4Address addr)

{

  NS_LOG_FUNCTION (this << addr);

  m_linkStateId = addr;

}

Ipv4Address

GlobalRoutingLSA::GetAdvertisingRouter (void) const

{

  NS_LOG_FUNCTION (this);

  return m_advertisingRtr;

}

void

GlobalRoutingLSA::SetAdvertisingRouter (Ipv4Address addr)

{

  NS_LOG_FUNCTION (this << addr);

  m_advertisingRtr = addr;

}

void

GlobalRoutingLSA::SetNetworkLSANetworkMask (Ipv4Mask mask)

{

  NS_LOG_FUNCTION (this << mask);

  m_networkLSANetworkMask = mask;

}

Ipv4Mask

GlobalRoutingLSA::GetNetworkLSANetworkMask (void) const

{

  NS_LOG_FUNCTION (this);

  return m_networkLSANetworkMask;

}

GlobalRoutingLSA::SPFStatus

GlobalRoutingLSA::GetStatus (void) const

{

  NS_LOG_FUNCTION (this);

  return m_status;

}

uint32_t

GlobalRoutingLSA::AddAttachedRouter (Ipv4Address addr)

{

  NS_LOG_FUNCTION (this << addr);

  m_attachedRouters.push_back (addr);

  return m_attachedRouters.size ();

}

uint32_t

GlobalRoutingLSA::GetNAttachedRouters (void) const

{

  NS_LOG_FUNCTION (this);

  return m_attachedRouters.size (); 

}

Ipv4Address

GlobalRoutingLSA::GetAttachedRouter (uint32_t n) const

{

  NS_LOG_FUNCTION (this << n);

  uint32_t j = 0;

  for ( ListOfAttachedRouters_t::const_iterator i = m_attachedRouters.begin ();

        i != m_attachedRouters.end (); 

        i++, j++)

    {

      if (j == n) 

        {

          return *i;

        }

    }

  NS_ASSERT_MSG (false, "GlobalRoutingLSA::GetAttachedRouter (): invalid index");

  return Ipv4Address ("0.0.0.0");

}

void

GlobalRoutingLSA::SetStatus (GlobalRoutingLSA::SPFStatus status)

{

  NS_LOG_FUNCTION (this << status);

  m_status = status;

}

Ptr<Node>

GlobalRoutingLSA::GetNode (void) const

{

  NS_LOG_FUNCTION (this);

  return NodeList::GetNode (m_node_id);

}

void

GlobalRoutingLSA::SetNode (Ptr<Node> node)

{

  NS_LOG_FUNCTION (this << node);

  m_node_id = node->GetId ();

}

void

GlobalRoutingLSA::Print (std::ostream &os) const

{

  NS_LOG_FUNCTION (this << &os);

  os << std::endl;

  os << "========== Global Routing LSA ==========" << std::endl;

  os << "m_lsType = " << m_lsType;

  if (m_lsType == GlobalRoutingLSA::RouterLSA) 

    {

      os << " (GlobalRoutingLSA::RouterLSA)";

    }

  else if (m_lsType == GlobalRoutingLSA::NetworkLSA) 

    {

      os << " (GlobalRoutingLSA::NetworkLSA)";

    }

  else if (m_lsType == GlobalRoutingLSA::ASExternalLSAs)

    {

      os << " (GlobalRoutingLSA::ASExternalLSA)";

    }

  else

    {

      os << "(Unknown LSType)";

    }

  os << std::endl;

  os << "m_linkStateId = " << m_linkStateId << " (Router ID)" << std::endl;

  os << "m_advertisingRtr = " << m_advertisingRtr << " (Router ID)" << std::endl;

  if (m_lsType == GlobalRoutingLSA::RouterLSA) 

    {

      for ( ListOfLinkRecords_t::const_iterator i = m_linkRecords.begin ();

            i != m_linkRecords.end (); 

            i++)

        {

          GlobalRoutingLinkRecord *p = *i;

          os << "---------- RouterLSA Link Record ----------" << std::endl;

          os << "m_linkType = " << p->m_linkType;

          if (p->m_linkType == GlobalRoutingLinkRecord::PointToPoint)

            {

              os << " (GlobalRoutingLinkRecord::PointToPoint)" << std::endl;

              os << "m_linkId = " << p->m_linkId << std::endl;

              os << "m_linkData = " << p->m_linkData << std::endl;

              os << "m_metric = " << p->m_metric << std::endl;

            }

          else if (p->m_linkType == GlobalRoutingLinkRecord::TransitNetwork)

            {

              os << " (GlobalRoutingLinkRecord::TransitNetwork)" << std::endl;

              os << "m_linkId = " << p->m_linkId << " (Designated router for network)" << std::endl;

              os << "m_linkData = " << p->m_linkData << " (This router's IP address)" << std::endl;

              os << "m_metric = " << p->m_metric << std::endl;

            }

          else if (p->m_linkType == GlobalRoutingLinkRecord::StubNetwork)

            {

              os << " (GlobalRoutingLinkRecord::StubNetwork)" << std::endl;

              os << "m_linkId = " << p->m_linkId << " (Network number of attached network)" << std::endl;

              os << "m_linkData = " << p->m_linkData << " (Network mask of attached network)" << std::endl;

              os << "m_metric = " << p->m_metric << std::endl;

            }

          else

            {

              os << " (Unknown LinkType)" << std::endl;

              os << "m_linkId = " << p->m_linkId << std::endl;

              os << "m_linkData = " << p->m_linkData << std::endl;

              os << "m_metric = " << p->m_metric << std::endl;

            }

          os << "---------- End RouterLSA Link Record ----------" << std::endl;

        }

    }

  else if (m_lsType == GlobalRoutingLSA::NetworkLSA) 

    {

      os << "---------- NetworkLSA Link Record ----------" << std::endl;

      os << "m_networkLSANetworkMask = " << m_networkLSANetworkMask << std::endl;

      for ( ListOfAttachedRouters_t::const_iterator i = m_attachedRouters.begin (); i != m_attachedRouters.end (); i++)

        {

          Ipv4Address p = *i;

          os << "attachedRouter = " << p << std::endl;

        }

      os << "---------- End NetworkLSA Link Record ----------" << std::endl;

    }

  else if (m_lsType == GlobalRoutingLSA::ASExternalLSAs)

    {

      os << "---------- ASExternalLSA Link Record --------" << std::endl;

      os << "m_linkStateId = " << m_linkStateId << std::endl;

      os << "m_networkLSANetworkMask = " << m_networkLSANetworkMask << std::endl;

    }

  else 

    {

      NS_ASSERT_MSG (0, "Illegal LSA LSType: " << m_lsType);

    }