/* -*- 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/ipv4.h"

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

#include "global-router-interface.h"

#include <vector>

NS_LOG_COMPONENT_DEFINE ("GlobalRouter");

namespace ns3 {

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

//

// 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_NOARGS ();

}

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_NOARGS ();

}

  Ipv4Address

GlobalRoutingLinkRecord::GetLinkId (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_linkId;

}

  void

GlobalRoutingLinkRecord::SetLinkId (Ipv4Address addr)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_linkId = addr;

}

  Ipv4Address

GlobalRoutingLinkRecord::GetLinkData (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_linkData;

}

  void

GlobalRoutingLinkRecord::SetLinkData (Ipv4Address addr)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_linkData = addr;

}

  GlobalRoutingLinkRecord::LinkType

GlobalRoutingLinkRecord::GetLinkType (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_linkType;

}

  void

GlobalRoutingLinkRecord::SetLinkType (

  GlobalRoutingLinkRecord::LinkType linkType)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_linkType = linkType;

}

  uint16_t

GlobalRoutingLinkRecord::GetMetric (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_metric;

}

  void

GlobalRoutingLinkRecord::SetMetric (uint16_t metric)

{

  NS_LOG_FUNCTION_NOARGS ();

  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)

{

  NS_LOG_FUNCTION_NOARGS ();

}

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)

{

  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)

{

  NS_LOG_FUNCTION_NOARGS ();

  NS_ASSERT_MSG(IsEmpty(), 

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

  CopyLinkRecords (lsa);

}

  GlobalRoutingLSA&

GlobalRoutingLSA::operator= (const GlobalRoutingLSA& lsa)

{

  NS_LOG_FUNCTION_NOARGS ();

  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;

  ClearLinkRecords ();

  CopyLinkRecords (lsa);

  return *this;

}

  void

GlobalRoutingLSA::CopyLinkRecords (const GlobalRoutingLSA& lsa)

{

  NS_LOG_FUNCTION_NOARGS ();

  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_NOARGS ();

  ClearLinkRecords ();

}

  void

GlobalRoutingLSA::ClearLinkRecords(void)

{

  NS_LOG_FUNCTION_NOARGS ();

  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_NOARGS ();

  m_linkRecords.push_back (lr);

  return m_linkRecords.size ();

}

  uint32_t

GlobalRoutingLSA::GetNLinkRecords (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_linkRecords.size ();

}

  GlobalRoutingLinkRecord *

GlobalRoutingLSA::GetLinkRecord (uint32_t n) const

{

  NS_LOG_FUNCTION_NOARGS ();

  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_NOARGS ();

  return m_linkRecords.size () == 0;

}

  GlobalRoutingLSA::LSType

GlobalRoutingLSA::GetLSType (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_lsType;

}

  void 

GlobalRoutingLSA::SetLSType (GlobalRoutingLSA::LSType typ) 

{

  NS_LOG_FUNCTION_NOARGS ();

  m_lsType = typ;

}

  Ipv4Address

GlobalRoutingLSA::GetLinkStateId (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_linkStateId;

}

  void

GlobalRoutingLSA::SetLinkStateId (Ipv4Address addr)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_linkStateId = addr;

}

  Ipv4Address

GlobalRoutingLSA::GetAdvertisingRouter (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_advertisingRtr;

}

  void

GlobalRoutingLSA::SetAdvertisingRouter (Ipv4Address addr)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_advertisingRtr = addr;

}

  void 

GlobalRoutingLSA::SetNetworkLSANetworkMask (Ipv4Mask mask)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_networkLSANetworkMask = mask;

}

  Ipv4Mask 

GlobalRoutingLSA::GetNetworkLSANetworkMask (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_networkLSANetworkMask;

}

  GlobalRoutingLSA::SPFStatus

GlobalRoutingLSA::GetStatus (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_status;

}

  uint32_t 

GlobalRoutingLSA::AddAttachedRouter (Ipv4Address addr)

{

  NS_LOG_FUNCTION_NOARGS ();

  m_attachedRouters.push_back (addr);

  return m_attachedRouters.size ();

}

  uint32_t 

GlobalRoutingLSA::GetNAttachedRouters (void) const

{

  NS_LOG_FUNCTION_NOARGS ();

  return m_attachedRouters.size (); 

}

  Ipv4Address 

GlobalRoutingLSA::GetAttachedRouter (uint32_t n) const

{

  NS_LOG_FUNCTION_NOARGS ();

  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_NOARGS ();

  m_status = status;

}

  void 

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

{

  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

    {

      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 

    {

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

    }

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

}

std::ostream& operator<< (std::ostream& os, GlobalRoutingLSA& lsa)

{

  lsa.Print (os);

  return os;

}

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

//

// GlobalRouter Implementation

//

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

NS_OBJECT_ENSURE_REGISTERED (GlobalRouter);

TypeId 

GlobalRouter::GetTypeId (void)

{

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

    .SetParent<Object> ();

  return tid;

}

GlobalRouter::GlobalRouter ()

  : m_LSAs()

{

  NS_LOG_FUNCTION_NOARGS ();

  m_routerId.Set(GlobalRouteManager::AllocateRouterId ());

}

GlobalRouter::~GlobalRouter ()

{

  NS_LOG_FUNCTION_NOARGS ();

  ClearLSAs();