Attachment #86 for bug #79

View | Details | Raw Unified | Return to bug 79
Collapse All | Expand All




FakeInternetNode::UpperDoSendUp (Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);
  NS_LOG_INFO ("**** Receive inbound packet");
  m_dtqInbound.Enqueue(p);
  return m_dtqInbound.Dequeue(p);

FakeInternetNode::UpperDoPull (Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  return m_dtqOutbound.Dequeue(p);
}

FakePhysicalLayer::UpperDoSendUp (Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  NS_ASSERT(m_upperPartner);
  return m_upperPartner->UpperSendUp(p);

FakePhysicalLayer::UpperDoPull (Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  return m_dtqOutbound.Dequeue(p);
}




OnOffApplication::SetMaxBytes(uint32_t maxBytes)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << maxBytes);
  m_maxBytes = maxBytes;
}


OnOffApplication::SetDefaultRate (const DataRate &rate)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (&rate);
  g_defaultRate.SetValue (rate);
}


OnOffApplication::SetDefaultSize (uint32_t size)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (size);
  g_defaultSize.SetValue (size);
}





  Application(n)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << n << serverAddress << serverPort << count
                 << interval << size);
    ", " << size << ")");

  Construct (n, serverAddress, serverPort, count, interval, size);
}

  uint32_t size)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << n << serverAddress << serverPort
                 << count << interval << size);
    ", " << size << ")");

  m_node = n;
  m_serverAddress = serverAddress;

  const Address &from) 
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << socket << packet << from);

  if (InetSocketAddress::IsMatchingType (from))
    {




  Application(n)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << n << port);

  Construct (n, port);
}

  uint16_t port)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << n << port);

  m_node = n;
  m_port = port;

  const Address &from) 
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << socket << packet << from);

  if (InetSocketAddress::IsMatchingType (from))
    {

(-)a/src/common/packet-metadata.cc (-2 / +2 lines)

Lines 703-709 PacketMetadata::DoAddHeader (uint32_t ui	Link Here

703

      m_metadataSkipped = true;

703

      m_metadataSkipped = true;

704

      return;

704

      return;

705

706

  NS_LOG_PARAM ("(uid=" << uid << ", size=" << size << ")");

706

  NS_LOG_PARAMS ("(uid=" << uid << ", size=" << size << ")");

707

708

  struct PacketMetadata::SmallItem item;

708

  struct PacketMetadata::SmallItem item;

709

  item.next = m_head;

709

  item.next = m_head;

Lines 723-729 PacketMetadata::DoRemoveHeader (uint32_t	Link Here

723

      m_metadataSkipped = true;

723

      m_metadataSkipped = true;

724

      return;

724

      return;

725

726

  NS_LOG_PARAM ("(uid=" << uid << ", size=" << size << ")");

726

  NS_LOG_PARAMS ("(uid=" << uid << ", size=" << size << ")");

727

  struct PacketMetadata::SmallItem item;

727

  struct PacketMetadata::SmallItem item;

728

  struct PacketMetadata::ExtraItem extraItem;

728

  struct PacketMetadata::ExtraItem extraItem;

729

  uint32_t read = ReadItems (m_head, &item, &extraItem);

729

  uint32_t read = ReadItems (m_head, &item, &extraItem);

(-)a/src/core/log.cc (+5 lines)

Lines 341-346 LogComponentPrintList (void)	Link Here

341

342

343

344

345

ParameterLogger g_parameterLogger;

346

EndParameterListStruct EndParameterList;

347

348

344

} // namespace ns3

349

} // namespace ns3

345

350

346

#endif // NS3_LOG_ENABLE

351

#endif // NS3_LOG_ENABLE





#endif


/**
 * \ingroup logging
 * \param msg message to output

 */

#ifdef NS3_LOG_ENABLE


namespace ns3 {

struct EndParameterListStruct {};
extern EndParameterListStruct EndParameterList;

struct ParameterName
{
  const char *name;
  ParameterName (const char *name_) : name (name_) {}
};

class ParameterLogger : public std::ostream
{
  int m_itemNumber;
  const char *m_parameterName;
public:
  ParameterLogger ()
    : m_itemNumber (0)
  {}

  template<typename T>
  ParameterLogger& operator<< (T param)
  {
    switch (m_itemNumber)
      {
      case 0: // first item is actually the function name
        if (m_parameterName)
          {
            std::clog << m_parameterName << "=" << param;
            m_parameterName = 0;
          }
        else
          {
            std::clog << param;
          }
        break;
      case 1:
        if (m_parameterName)
          {
            std::clog << ", " << m_parameterName << "=" << param;
            m_parameterName = 0;
          }
        else
          {
            std::clog << ", " << param;
          }
        break;
      default: // parameter following a previous parameter
        std::clog << ", " << param;
        break;
      }
    m_itemNumber++;
    return *this;
  }

  ParameterLogger&
  operator << (ParameterName paramName)
  {
    m_parameterName = paramName.name;
    return *this;
  }
  
  ParameterLogger&
  operator << (EndParameterListStruct dummy)
  {
    std::clog << ")" << std::endl;
    m_itemNumber = 0;
    return *this;
  }
};

extern ParameterLogger g_parameterLogger;

}



/**
 * \param level the log level

#define NS_LOG_FUNCTION \
  NS_LOG_F(ns3::LOG_FUNCTION)



#define NS_LOG_PARAMS(parameters)                       \
  do                                                    \
    {                                                   \
      if (g_log.IsEnabled (ns3::LOG_PARAM))             \
        {                                               \
          g_parameterLogger << __PRETTY_FUNCTION__      \
                            << parameters               \
                            << EndParameterList;        \
        }                                               \
    }                                                   \
  while (false)


#define NS_LOG_PARAMS_BEGIN()                           \
      if (g_log.IsEnabled (ns3::LOG_PARAM))             \
        {                                               \
          g_parameterLogger << __PRETTY_FUNCTION__;

#define NS_LOG_PARAM(param) \
          g_parameterLogger << ParameterName (#param) << param;

#define NS_LOG_PARAMS_END()                             \
          g_parameterLogger << EndParameterList;        \
        }


#define NS_LOG_LOGIC(msg) \
  NS_LOG(ns3::LOG_LOGIC, msg)




  m_delay (delay)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << Channel::GetName() << bps.GetBitRate() << delay);
    ", " << delay << ")");
  Init();
}


  m_delay (delay)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << name << bps.GetBitRate() << delay);
    ")");
  Init();
}


CsmaChannel::Attach(Ptr<CsmaNetDevice> device)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << device);
  NS_ASSERT(device != 0);

  CsmaDeviceRec rec(device);

CsmaChannel::Reattach(Ptr<CsmaNetDevice> device)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << device);
  NS_ASSERT(device != 0);

  std::vector<CsmaDeviceRec>::iterator it;

CsmaChannel::Reattach(uint32_t deviceId)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << deviceId);

  if (deviceId < m_deviceList.size())
    {

CsmaChannel::Detach(uint32_t deviceId)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << deviceId);

  if (deviceId < m_deviceList.size())
    {

CsmaChannel::Detach(Ptr<CsmaNetDevice> device)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << device);
  NS_ASSERT(device != 0);

  std::vector<CsmaDeviceRec>::iterator it;

CsmaChannel::TransmitStart(Packet& p, uint32_t srcId)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p << srcId);
  NS_LOG_INFO ("UID is " << p.GetUid () << ")");

  if (m_state != IDLE)

CsmaChannel::TransmitEnd()
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &m_currentPkt << m_currentSrc);
  NS_LOG_INFO ("UID is " << m_currentPkt.GetUid () << ")");

  NS_ASSERT(m_state == TRANSMITTING);

CsmaChannel::PropagationCompleteEvent()
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &m_currentPkt);
  NS_LOG_INFO ("UID is " << m_currentPkt.GetUid () << ")");

  NS_ASSERT(m_state == PROPAGATING);




    m_bps (DataRate (0xffffffff))
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << node);
  m_encapMode = IP_ARP;
  Init(true, true);
}

    m_bps (DataRate (0xffffffff))
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << node);
  m_encapMode = encapMode;

  Init(true, true);

    m_bps (DataRate (0xffffffff))
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << node);
  m_encapMode = encapMode;

  Init(sendEnable, receiveEnable);

CsmaNetDevice::operator= (const CsmaNetDevice nd)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &nd);
  return *this;
}
*/

CsmaNetDevice::Attach (Ptr<CsmaChannel> ch)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &ch);

  m_channel = ch;


CsmaNetDevice::AddQueue (Ptr<Queue> q)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << q);

  m_queue = q;
}

CsmaNetDevice::MakeMulticastAddress(Ipv4Address multicastGroup) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << multicastGroup);
//
// First, get the generic multicast address.
//




  m_nDevices(0)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << Channel::GetName() << bps.GetBitRate() << delay);
    ", " << delay << ")");
}

PointToPointChannel::PointToPointChannel(

  m_nDevices(0)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << name << bps.GetBitRate() << delay);
    delay << ")");
}

void
PointToPointChannel::Attach(Ptr<PointToPointNetDevice> device)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << device);
  NS_ASSERT(m_nDevices < N_DEVICES && "Only two devices permitted");
  NS_ASSERT(device != 0);


                                        const Time& txTime)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p << src);
  NS_LOG_LOGIC ("UID is " << p.GetUid () << ")");

  NS_ASSERT(m_link[0].m_state != INITIALIZING);




  m_rxTrace ()
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << node);
//
// XXX BUGBUG
//

PointToPointNetDevice::TransmitStart (Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);
  NS_LOG_LOGIC ("UID is " << p.GetUid () << ")");
//
// This function is called to start the process of transmitting a packet.

PointToPointNetDevice::Attach (Ptr<PointToPointChannel> ch)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &ch);

  m_channel = ch;


void PointToPointNetDevice::AddQueue (Ptr<Queue> q)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << q);

  m_queue = q;
}

void PointToPointNetDevice::Receive (Packet& p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);
  uint16_t protocol = 0;
  Packet packet = p;


(-)a/src/internet-node/arp-ipv4-interface.cc (-1 / +1 lines)

Lines 64-70 ArpIpv4Interface::SendTo (Packet p, Ipv4	Link Here

ArpIpv4Interface::SendTo (Packet p, Ipv4Address dest)

ArpIpv4Interface::SendTo (Packet p, Ipv4Address dest)

  NS_LOG_FUNCTION;

  NS_LOG_FUNCTION;

  NS_LOG_PARAM ("(" << &p << ", " << dest << ")");

  NS_LOG_PARAMS (this << &p << dest);

  NS_ASSERT (GetDevice () != 0);

  NS_ASSERT (GetDevice () != 0);

  if (GetDevice ()->NeedsArp ())

  if (GetDevice ()->NeedsArp ())




Ipv4EndPointDemux::Allocate (Ipv4Address address)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << address);
  uint16_t port = AllocateEphemeralPort ();
  if (port == 0) 
    {

Ipv4EndPointDemux::Allocate (Ipv4Address address, uint16_t port)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << address << port);
  if (LookupLocal (address, port)) 
    {
      NS_LOG_WARN ("Duplicate address/port; failing.");

			     Ipv4Address peerAddress, uint16_t peerPort)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << localAddress << localPort << peerAddress << peerPort);
    << ", localPort=" << localPort
    << ", peerAddress=" << peerAddress
    << ", peerPort=" << peerPort << ")");
  for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) 
    {
      if ((*i)->GetLocalPort () == localPort &&

  Ipv4EndPoint *generic = 0;
  EndPoints retval;

  //NS_LOG_PARAMS (this << daddr << dport << saddr << sport);
  NS_LOG_PARAMS_BEGIN ();
  NS_LOG_PARAM (this);
  NS_LOG_PARAM (daddr);
  NS_LOG_PARAM (dport);
  NS_LOG_PARAM (saddr);
  NS_LOG_PARAM (sport);
  NS_LOG_PARAM (incomingInterface);
  NS_LOG_PARAMS_END ();

  for (EndPointsI i = m_endPoints.begin (); i != m_endPoints.end (); i++) 
    {




    m_metric(1)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &nd);
}

Ipv4Interface::~Ipv4Interface ()

Ipv4Interface::SetAddress (Ipv4Address a)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << a);
  m_address = a;
}


Ipv4Interface::SetNetworkMask (Ipv4Mask mask)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << mask);
  m_netmask = mask;
}


Ipv4Interface::SetMetric (uint16_t metric)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS ("(" << metric << ")");
  m_metric = metric;
}





                      uint32_t interface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << dest << nextHop << interface);
  m_staticRouting->AddHostRouteTo (dest, nextHop, interface);
}


				uint32_t interface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << dest << interface);
  m_staticRouting->AddHostRouteTo (dest, interface);
}


				   uint32_t interface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << network << networkMask << nextHop << interface);
    ", " << interface << ")");
  m_staticRouting->AddNetworkRouteTo (network, networkMask, nextHop, interface);
}


				   uint32_t interface)
{
  NS_LOG_FUNCTION; 
  NS_LOG_PARAMS (this << network << networkMask << interface);
    ")");
  m_staticRouting->AddNetworkRouteTo (network, networkMask, interface);
}


				 uint32_t interface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << nextHop << interface);
  m_staticRouting->SetDefaultRoute (nextHop, interface);
}


  Ipv4RoutingProtocol::RouteReplyCallback routeReply)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &ipHeader << &packet << &routeReply);

  Lookup (Ipv4RoutingProtocol::IF_INDEX_ANY, ipHeader, packet, routeReply);
}

  Ipv4RoutingProtocol::RouteReplyCallback routeReply)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << ifIndex << &ipHeader << &packet << &routeReply);
    &routeReply << ")");

  for (Ipv4RoutingProtocolList::const_iterator rprotoIter = 
         m_routingProtocols.begin ();

                                    int priority)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &routingProtocol << priority);
  m_routingProtocols.push_back
    (std::pair<int, Ptr<Ipv4RoutingProtocol> > (-priority, routingProtocol));
  m_routingProtocols.sort ();

Ipv4L3Protocol::RemoveRoute (uint32_t index)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << index);
  m_staticRouting->RemoveRoute (index);
}


                                   std::vector<uint32_t> outputInterfaces)
{
  NS_LOG_FUNCTION; 
  NS_LOG_PARAMS (this << origin << group << inputInterface << &outputInterfaces);
    ", " << &outputInterfaces << ")");

  m_staticRouting->AddMulticastRoute (origin, group, inputInterface,
    outputInterfaces);

Ipv4L3Protocol::SetDefaultMulticastRoute (uint32_t outputInterface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << outputInterface);

  m_staticRouting->SetDefaultMulticastRoute (outputInterface);
}

Ipv4L3Protocol::GetMulticastRoute (uint32_t index) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << index);
  return m_staticRouting->GetMulticastRoute (index);
}


                                       uint32_t inputInterface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << origin << group << inputInterface);
    ")");
  m_staticRouting->RemoveMulticastRoute (origin, group, inputInterface);
}


Ipv4L3Protocol::RemoveMulticastRoute (uint32_t index)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << index);
  m_staticRouting->RemoveMulticastRoute (index);
}


Ipv4L3Protocol::AddInterface (Ptr<NetDevice> device)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &device);
  Ptr<Ipv4Interface> interface = Create<ArpIpv4Interface> (m_node, device);
  return AddIpv4Interface (interface);
}

Ipv4L3Protocol::AddIpv4Interface (Ptr<Ipv4Interface>interface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << interface);
  uint32_t index = m_nInterfaces;
  m_interfaces.push_back (interface);
  m_nInterfaces++;

Ipv4L3Protocol::GetInterface (uint32_t index) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << index);
  uint32_t tmp = 0;
  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
    {

Ipv4L3Protocol::FindInterfaceForAddr (Ipv4Address addr) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << addr);

  uint32_t ifIndex = 0;
  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

Ipv4L3Protocol::FindInterfaceForAddr (Ipv4Address addr, Ipv4Mask mask) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << addr << mask);

  uint32_t ifIndex = 0;
  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); 

Ipv4L3Protocol::FindInterfaceForDevice (Ptr<const NetDevice> device)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &device);
  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin (); i != m_interfaces.end (); i++)
    {
      if ((*i)->GetDevice () == device)

Ipv4L3Protocol::Receive( Ptr<NetDevice> device, const Packet& p, uint16_t protocol, const Address &from)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &device << &p << protocol <<  from);
    from << ")");

  NS_LOG_LOGIC ("Packet from " << from);


            uint8_t protocol)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &packet << source << destination << protocol);
    destination << ", " << protocol << ")");

  Ipv4Header ipHeader;


                             Ipv4Header const &ipHeader)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << found << &route << &packet << &ipHeader);
    &ipHeader << ")");

  if (!found)
    {

  Ptr<NetDevice> device)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (ifIndex << &packet << &ipHeader<< device);
    ", " << device << ")");

  for (Ipv4InterfaceList::const_iterator i = m_interfaces.begin ();
       i != m_interfaces.end (); i++) 

                           Ptr<Ipv4Interface> incomingInterface)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p << &ip);

  Ptr<Ipv4L4Demux> demux = m_node->QueryInterface<Ipv4L4Demux> (Ipv4L4Demux::iid);
  Ptr<Ipv4L4Protocol> protocol = demux->GetProtocol (ip.GetProtocol ());

Ipv4L3Protocol::JoinMulticastGroup (Ipv4Address origin, Ipv4Address group)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << origin << group);
  m_multicastGroups.push_back(
    std::pair<Ipv4Address, Ipv4Address> (origin, group));
}

Ipv4L3Protocol::LeaveMulticastGroup (Ipv4Address origin, Ipv4Address group)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << origin << group);

  for (Ipv4MulticastGroupList::iterator i = m_multicastGroups.begin ();
       i != m_multicastGroups.end (); 

Ipv4L3Protocol::SetAddress (uint32_t i, Ipv4Address address)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << i << address);
  Ptr<Ipv4Interface> interface = GetInterface (i);
  interface->SetAddress (address);
}

Ipv4L3Protocol::SetNetworkMask (uint32_t i, Ipv4Mask mask)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << i << mask);
  Ptr<Ipv4Interface> interface = GetInterface (i);
  interface->SetNetworkMask (mask);
}

Ipv4L3Protocol::GetNetworkMask (uint32_t i) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << i);
  Ptr<Ipv4Interface> interface = GetInterface (i);
  return interface->GetNetworkMask ();
}

Ipv4L3Protocol::GetAddress (uint32_t i) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << i);
  Ptr<Ipv4Interface> interface = GetInterface (i);
  return interface->GetAddress ();
}

Ipv4L3Protocol::SetMetric (uint32_t i, uint16_t metric)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS ("(" << i << ", " << metric << ")");
  Ptr<Ipv4Interface> interface = GetInterface (i);
  interface->SetMetric (metric);
}

Ipv4L3Protocol::GetMetric (uint32_t i) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS ("(" << i << ")");
  Ptr<Ipv4Interface> interface = GetInterface (i);
  return interface->GetMetric ();
}

  Ipv4Address destination, uint32_t& ifIndex) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << destination << &ifIndex);
//
// The first thing we do in trying to determine a source address is to 
// consult the routing protocols.  These will also check for a default route

Ipv4L3Protocol::GetMtu (uint32_t i) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << i);
  Ptr<Ipv4Interface> interface = GetInterface (i);
  return interface->GetMtu ();
}

Ipv4L3Protocol::IsUp (uint32_t i) const
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << i);
  Ptr<Ipv4Interface> interface = GetInterface (i);
  return interface->IsUp ();
}

Ipv4L3Protocol::SetUp (uint32_t i)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << i);
  Ptr<Ipv4Interface> interface = GetInterface (i);
  interface->SetUp ();


Ipv4L3Protocol::SetDown (uint32_t ifaceIndex)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << ifaceIndex);
  Ptr<Ipv4Interface> interface = GetInterface (ifaceIndex);
  interface->SetDown ();


(-)a/src/internet-node/ipv4-loopback-interface.cc (-1 / +1 lines)

Lines 47-53 Ipv4LoopbackInterface::SendTo (Packet pa	Link Here

Ipv4LoopbackInterface::SendTo (Packet packet, Ipv4Address dest)

Ipv4LoopbackInterface::SendTo (Packet packet, Ipv4Address dest)

  NS_LOG_FUNCTION;

  NS_LOG_FUNCTION;

  NS_LOG_PARAM ("(" << &packet << ", " << dest << ")");

  NS_LOG_PARAMS (this << &packet << dest);

  Ptr<Ipv4L3Protocol> ipv4 =

  Ptr<Ipv4L3Protocol> ipv4 =

    m_node->QueryInterface<Ipv4L3Protocol> (Ipv4L3Protocol::iid);

    m_node->QueryInterface<Ipv4L3Protocol> (Ipv4L3Protocol::iid);

(-)a/src/internet-node/ipv4-static-routing.cc (-3 / +2 lines)

Lines 522-529 Ipv4StaticRouting::RequestRoute (	Link Here

522

  RouteReplyCallback routeReply)

522

  RouteReplyCallback routeReply)

523

524

  NS_LOG_FUNCTION;

524

  NS_LOG_FUNCTION;

525

  NS_LOG_PARAM ("(" << ifIndex << &ipHeader << ", " << &packet << ", " <<

525

  NS_LOG_PARAMS (this << ifIndex << &ipHeader << &packet << &routeReply);

526

    &routeReply << ")");

527

526

528

  NS_LOG_LOGIC ("source = " << ipHeader.GetSource ());

527

  NS_LOG_LOGIC ("source = " << ipHeader.GetSource ());

529

528

Lines 576-582 Ipv4StaticRouting::RequestIfIndex (Ipv4A	Link Here

576

Ipv4StaticRouting::RequestIfIndex (Ipv4Address destination, uint32_t& ifIndex)

575

Ipv4StaticRouting::RequestIfIndex (Ipv4Address destination, uint32_t& ifIndex)

577

576

578

  NS_LOG_FUNCTION;

577

  NS_LOG_FUNCTION;

579

  NS_LOG_PARAM ("(" << destination << ", " << &ifIndex << ")");

578

  NS_LOG_PARAMS (this << destination << &ifIndex);

580

//

579

//

581

// First, see if this is a multicast packet we have a route for.  If we

580

// First, see if this is a multicast packet we have a route for.  If we

582

// have a route, then send the packet down each of the specified interfaces.

581

// have a route, then send the packet down each of the specified interfaces.




UdpL4Protocol::Allocate (Ipv4Address address)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << address);
  return m_endPoints->Allocate (address);
}


UdpL4Protocol::Allocate (uint16_t port)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << port);
  return m_endPoints->Allocate (port);
}


UdpL4Protocol::Allocate (Ipv4Address address, uint16_t port)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << address << port);
  return m_endPoints->Allocate (address, port);
}
Ipv4EndPoint *

               Ipv4Address peerAddress, uint16_t peerPort)
{
  NS_LOG_FUNCTION; 
  NS_LOG_PARAMS (this << localAddress << localPort << peerAddress << peerPort);
    peerAddress << ", " << peerPort << ")");
  return m_endPoints->Allocate (localAddress, localPort,
                                peerAddress, peerPort);
}

UdpL4Protocol::DeAllocate (Ipv4EndPoint *endPoint)
{
  NS_LOG_FUNCTION; 
  NS_LOG_PARAMS (this << endPoint);
  m_endPoints->DeAllocate (endPoint);
}


                       Ptr<Ipv4Interface> interface)
{
  NS_LOG_FUNCTION; 
  NS_LOG_PARAMS (this << &packet << source << destination);
    ")");

  UdpHeader udpHeader;
  packet.RemoveHeader (udpHeader);

           uint16_t sport, uint16_t dport)
{
  NS_LOG_FUNCTION; 
  NS_LOG_PARAMS (this << &packet << saddr << daddr << sport << dport);
    sport << ", " << dport << ")");

  UdpHeader udpHeader;
  udpHeader.SetDestination (dport);




UdpSocket::Bind (const Address &address)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << address);

  if (!InetSocketAddress::IsMatchingType (address))
    {

UdpSocket::Connect(const Address & address)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << address);
  Ipv4Route routeToDest;
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
  m_defaultAddress = transport.GetIpv4 ();

UdpSocket::Send (const Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  if (!m_connected)
    {

UdpSocket::DoSendTo (const Packet &p, const Address &address)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p << address);

  if (!m_connected)
    {

UdpSocket::DoSendTo (const Packet &p, Ipv4Address dest, uint16_t port)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p << dest << port);

  Ipv4Route routeToDest;


UdpSocket::SendTo(const Address &address, const Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << address << &p);
  InetSocketAddress transport = InetSocketAddress::ConvertFrom (address);
  Ipv4Address ipv4 = transport.GetIpv4 ();
  uint16_t port = transport.GetPort ();

UdpSocket::ForwardUp (const Packet &packet, Ipv4Address ipv4, uint16_t port)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &packet << ipv4 << port);

  if (m_shutdownRecv)
    {

(-)a/src/node/channel.cc (-2 / +2 lines)

Lines 37-43 Channel::Channel (std::string name)	Link Here

  : m_name(name)

  : m_name(name)

  NS_LOG_FUNCTION;

  NS_LOG_FUNCTION;

  NS_LOG_PARAM ("(" << name << ")");

  NS_LOG_PARAMS (this << name);

  SetInterfaceId (Channel::iid);

  SetInterfaceId (Channel::iid);

Lines 50-56 Channel::SetName(std::string name)	Link Here

Channel::SetName(std::string name)

Channel::SetName(std::string name)

  NS_LOG_FUNCTION;

  NS_LOG_FUNCTION;

  NS_LOG_PARAM ("(" << name << ")");

  NS_LOG_PARAMS (this << name);

  m_name = name;

  m_name = name;




DropTailQueue::SetMaxPackets (uint32_t npackets)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << npackets);
  m_maxPackets = npackets;
}


DropTailQueue::DoEnqueue (const Packet& p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  if (m_packets.size () >= m_maxPackets)
    {

DropTailQueue::DoDequeue (Packet& p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  if (m_packets.empty()) 
    {

DropTailQueue::DoPeek (Packet& p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  if (m_packets.empty()) 
    {




Queue::Enqueue (const Packet& p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);
  NS_LOG_LOGIC ("m_traceEnqueue (p)");

  m_traceEnqueue (p);

Queue::Dequeue (Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  bool retval = DoDequeue (p);


Queue::Peek (Packet &p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);
  return DoPeek (p);
}


Queue::Drop (const Packet& p)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << &p);

  m_nTotalDroppedPackets++;
  m_nTotalDroppedBytes += p.GetSize ();

(-)a/src/routing/global-routing/candidate-queue.cc (-1 / +1 lines)

Lines 52-58 CandidateQueue::Push (SPFVertex *vNew)	Link Here

CandidateQueue::Push (SPFVertex *vNew)

CandidateQueue::Push (SPFVertex *vNew)

  NS_LOG_FUNCTION;

  NS_LOG_FUNCTION;

  NS_LOG_PARAM ("(" << vNew << ")");

  NS_LOG_PARAMS (this << vNew);

  CandidateList_t::iterator i = m_candidates.begin ();

  CandidateList_t::iterator i = m_candidates.begin ();

(-)a/src/routing/global-routing/global-route-manager-impl.cc (-1 / +1 lines)

Lines 975-981 GlobalRouteManagerImpl::SPFCalculate (Ip	Link Here

975

GlobalRouteManagerImpl::SPFCalculate (Ipv4Address root)

975

GlobalRouteManagerImpl::SPFCalculate (Ipv4Address root)

976

977

  NS_LOG_FUNCTION;

977

  NS_LOG_FUNCTION;

978

  NS_LOG_PARAM ("(" << root << ")");

978

  NS_LOG_PARAMS (this << root);

979

980

  SPFVertex *v;

980

  SPFVertex *v;

981

//

981

//




  m_metric (metric)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << linkType << linkId << linkData << metric);
    ", " << metric << ")");
}

GlobalRoutingLinkRecord::~GlobalRoutingLinkRecord ()

  m_status(status)
{
  NS_LOG_FUNCTION;
  NS_LOG_PARAMS (this << status << linkStateId << advertisingRtr);
    advertisingRtr << ")");
}

GlobalRoutingLSA::GlobalRoutingLSA (GlobalRoutingLSA& lsa)

Return to bug 79