df/dcf/internet-trace-helper_8cc_source.html

/*

 * Copyright (c) 2010 University of Washington

 *

 * SPDX-License-Identifier: GPL-2.0-only

 */


#include "internet-trace-helper.h"


#include "ns3/abort.h"

#include "ns3/assert.h"

#include "ns3/log.h"

#include "ns3/names.h"

#include "ns3/net-device.h"

#include "ns3/node.h"

#include "ns3/pcap-file-wrapper.h"

#include "ns3/ptr.h"


#include <fstream>

#include <stdint.h>

#include <string>


namespace ns3

{


NS_LOG_COMPONENT_DEFINE("InternetTraceHelper");


void


PcapHelperForIpv4::EnablePcapIpv4(std::string prefix,

                                  Ptr<Ipv4> ipv4,

                                  uint32_t interface,

                                  bool explicitFilename)

{

    EnablePcapIpv4Internal(prefix, ipv4, interface, explicitFilename);

}


void


PcapHelperForIpv4::EnablePcapIpv4(std::string prefix,

                                  std::string ipv4Name,

                                  uint32_t interface,

                                  bool explicitFilename)

{

    Ptr<Ipv4> ipv4 = Names::Find<Ipv4>(ipv4Name);

    EnablePcapIpv4(prefix, ipv4, interface, explicitFilename);

}


void


PcapHelperForIpv4::EnablePcapIpv4(std::string prefix, Ipv4InterfaceContainer c)

{

    for (auto i = c.Begin(); i != c.End(); ++i)

    {

        EnablePcapIpv4(prefix, (*i).first, (*i).second, false);

    }

}


void


PcapHelperForIpv4::EnablePcapIpv4(std::string prefix, NodeContainer n)

{

    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        Ptr<Ipv4> ipv4 = node->GetObject<Ipv4>();

        if (ipv4)

        {

            for (uint32_t j = 0; j < ipv4->GetNInterfaces(); ++j)

            {

                EnablePcapIpv4(prefix, ipv4, j, false);

            }

        }

    }

}


void


PcapHelperForIpv4::EnablePcapIpv4All(std::string prefix)

{

    EnablePcapIpv4(prefix, NodeContainer::GetGlobal());

}


void


PcapHelperForIpv4::EnablePcapIpv4(std::string prefix,

                                  uint32_t nodeid,

                                  uint32_t interface,

                                  bool explicitFilename)

{

    NodeContainer n = NodeContainer::GetGlobal();


    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        if (node->GetId() != nodeid)

        {

            continue;

        }


        Ptr<Ipv4> ipv4 = node->GetObject<Ipv4>();

        if (ipv4)

        {

            EnablePcapIpv4(prefix, ipv4, interface, explicitFilename);

        }

        return;

    }

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(std::string prefix,

                                         Ptr<Ipv4> ipv4,

                                         uint32_t interface,

                                         bool explicitFilename)

{

    EnableAsciiIpv4Internal(Ptr<OutputStreamWrapper>(), prefix, ipv4, interface, explicitFilename);

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(Ptr<OutputStreamWrapper> stream,

                                         Ptr<Ipv4> ipv4,

                                         uint32_t interface)

{

    EnableAsciiIpv4Internal(stream, std::string(), ipv4, interface, false);

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(std::string prefix,

                                         std::string ipv4Name,

                                         uint32_t interface,

                                         bool explicitFilename)

{

    EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper>(), prefix, ipv4Name, interface, explicitFilename);

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(Ptr<OutputStreamWrapper> stream,

                                         std::string ipv4Name,

                                         uint32_t interface)

{

    EnableAsciiIpv4Impl(stream, std::string(), ipv4Name, interface, false);

}


//

// Private API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             std::string ipv4Name,

                                             uint32_t interface,

                                             bool explicitFilename)

{

    Ptr<Ipv4> ipv4 = Names::Find<Ipv4>(ipv4Name);

    EnableAsciiIpv4Internal(stream, prefix, ipv4, interface, explicitFilename);

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(std::string prefix, Ipv4InterfaceContainer c)

{

    EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper>(), prefix, c);

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(Ptr<OutputStreamWrapper> stream, Ipv4InterfaceContainer c)

{

    EnableAsciiIpv4Impl(stream, std::string(), c);

}


//

// Private API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             Ipv4InterfaceContainer c)

{

    for (auto i = c.Begin(); i != c.End(); ++i)

    {

        EnableAsciiIpv4Internal(stream, prefix, (*i).first, (*i).second, false);

    }

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(std::string prefix, NodeContainer n)

{

    EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper>(), prefix, n);

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(Ptr<OutputStreamWrapper> stream, NodeContainer n)

{

    EnableAsciiIpv4Impl(stream, std::string(), n);

}


//

// Private API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             NodeContainer n)

{

    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        Ptr<Ipv4> ipv4 = node->GetObject<Ipv4>();

        if (ipv4)

        {

            for (uint32_t j = 0; j < ipv4->GetNInterfaces(); ++j)

            {

                EnableAsciiIpv4Internal(stream, prefix, ipv4, j, false);

            }

        }

    }

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4All(std::string prefix)

{

    EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper>(), prefix, NodeContainer::GetGlobal());

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4All(Ptr<OutputStreamWrapper> stream)

{

    EnableAsciiIpv4Impl(stream, std::string(), NodeContainer::GetGlobal());

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(Ptr<OutputStreamWrapper> stream,

                                         uint32_t nodeid,

                                         uint32_t interface,

                                         bool explicitFilename)

{

    EnableAsciiIpv4Impl(stream, std::string(), nodeid, interface, explicitFilename);

}


//

// Public API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4(std::string prefix,

                                         uint32_t nodeid,

                                         uint32_t interface,

                                         bool explicitFilename)

{

    EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper>(), prefix, nodeid, interface, explicitFilename);

}


//

// Private API

//

void


AsciiTraceHelperForIpv4::EnableAsciiIpv4Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             uint32_t nodeid,

                                             uint32_t interface,

                                             bool explicitFilename)

{

    NodeContainer n = NodeContainer::GetGlobal();


    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        if (node->GetId() != nodeid)

        {

            continue;

        }


        Ptr<Ipv4> ipv4 = node->GetObject<Ipv4>();

        if (ipv4)

        {

            EnableAsciiIpv4Internal(stream, prefix, ipv4, interface, explicitFilename);

        }


        return;

    }

}


void


PcapHelperForIpv6::EnablePcapIpv6(std::string prefix,

                                  Ptr<Ipv6> ipv6,

                                  uint32_t interface,

                                  bool explicitFilename)

{

    EnablePcapIpv6Internal(prefix, ipv6, interface, explicitFilename);

}


void


PcapHelperForIpv6::EnablePcapIpv6(std::string prefix,

                                  std::string ipv6Name,

                                  uint32_t interface,

                                  bool explicitFilename)

{

    Ptr<Ipv6> ipv6 = Names::Find<Ipv6>(ipv6Name);

    EnablePcapIpv6(prefix, ipv6, interface, explicitFilename);

}


void


PcapHelperForIpv6::EnablePcapIpv6(std::string prefix, Ipv6InterfaceContainer c)

{

    for (auto i = c.Begin(); i != c.End(); ++i)

    {

        EnablePcapIpv6(prefix, (*i).first, (*i).second, false);

    }

}


void


PcapHelperForIpv6::EnablePcapIpv6(std::string prefix, NodeContainer n)

{

    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        Ptr<Ipv6> ipv6 = node->GetObject<Ipv6>();

        if (ipv6)

        {

            for (uint32_t j = 0; j < ipv6->GetNInterfaces(); ++j)

            {

                EnablePcapIpv6(prefix, ipv6, j, false);

            }

        }

    }

}


void


PcapHelperForIpv6::EnablePcapIpv6All(std::string prefix)

{

    EnablePcapIpv6(prefix, NodeContainer::GetGlobal());

}


void


PcapHelperForIpv6::EnablePcapIpv6(std::string prefix,

                                  uint32_t nodeid,

                                  uint32_t interface,

                                  bool explicitFilename)

{

    NodeContainer n = NodeContainer::GetGlobal();


    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        if (node->GetId() != nodeid)

        {

            continue;

        }


        Ptr<Ipv6> ipv6 = node->GetObject<Ipv6>();

        if (ipv6)

        {

            EnablePcapIpv6(prefix, ipv6, interface, explicitFilename);

        }

        return;

    }

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(std::string prefix,

                                         Ptr<Ipv6> ipv6,

                                         uint32_t interface,

                                         bool explicitFilename)

{

    EnableAsciiIpv6Internal(Ptr<OutputStreamWrapper>(), prefix, ipv6, interface, explicitFilename);

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(Ptr<OutputStreamWrapper> stream,

                                         Ptr<Ipv6> ipv6,

                                         uint32_t interface)

{

    EnableAsciiIpv6Internal(stream, std::string(), ipv6, interface, false);

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(std::string prefix,

                                         std::string ipv6Name,

                                         uint32_t interface,

                                         bool explicitFilename)

{

    EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper>(), prefix, ipv6Name, interface, explicitFilename);

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(Ptr<OutputStreamWrapper> stream,

                                         std::string ipv6Name,

                                         uint32_t interface)

{

    EnableAsciiIpv6Impl(stream, std::string(), ipv6Name, interface, false);

}


//

// Private API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             std::string ipv6Name,

                                             uint32_t interface,

                                             bool explicitFilename)

{

    Ptr<Ipv6> ipv6 = Names::Find<Ipv6>(ipv6Name);

    EnableAsciiIpv6Internal(stream, prefix, ipv6, interface, explicitFilename);

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(std::string prefix, Ipv6InterfaceContainer c)

{

    EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper>(), prefix, c);

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(Ptr<OutputStreamWrapper> stream, Ipv6InterfaceContainer c)

{

    EnableAsciiIpv6Impl(stream, std::string(), c);

}


//

// Private API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             Ipv6InterfaceContainer c)

{

    for (auto i = c.Begin(); i != c.End(); ++i)

    {

        EnableAsciiIpv6Internal(stream, prefix, (*i).first, (*i).second, false);

    }

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(std::string prefix, NodeContainer n)

{

    EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper>(), prefix, n);

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(Ptr<OutputStreamWrapper> stream, NodeContainer n)

{

    EnableAsciiIpv6Impl(stream, std::string(), n);

}


//

// Private API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             NodeContainer n)

{

    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        Ptr<Ipv6> ipv6 = node->GetObject<Ipv6>();

        if (ipv6)

        {

            for (uint32_t j = 0; j < ipv6->GetNInterfaces(); ++j)

            {

                EnableAsciiIpv6Internal(stream, prefix, ipv6, j, false);

            }

        }

    }

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6All(std::string prefix)

{

    EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper>(), prefix, NodeContainer::GetGlobal());

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6All(Ptr<OutputStreamWrapper> stream)

{

    EnableAsciiIpv6Impl(stream, std::string(), NodeContainer::GetGlobal());

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(Ptr<OutputStreamWrapper> stream,

                                         uint32_t nodeid,

                                         uint32_t interface)

{

    EnableAsciiIpv6Impl(stream, std::string(), nodeid, interface, false);

}


//

// Public API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6(std::string prefix,

                                         uint32_t nodeid,

                                         uint32_t interface,

                                         bool explicitFilename)

{

    EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper>(), prefix, nodeid, interface, explicitFilename);

}


//

// Private API

//

void


AsciiTraceHelperForIpv6::EnableAsciiIpv6Impl(Ptr<OutputStreamWrapper> stream,

                                             std::string prefix,

                                             uint32_t nodeid,

                                             uint32_t interface,

                                             bool explicitFilename)

{

    NodeContainer n = NodeContainer::GetGlobal();


    for (auto i = n.Begin(); i != n.End(); ++i)

    {

        Ptr<Node> node = *i;

        if (node->GetId() != nodeid)

        {

            continue;

        }


        Ptr<Ipv6> ipv6 = node->GetObject<Ipv6>();

        if (ipv6)

        {

            EnableAsciiIpv6Internal(stream, prefix, ipv6, interface, explicitFilename);

        }


        return;

    }

}


} // namespace ns3

ns3::AsciiTraceHelperForIpv4::EnableAsciiIpv4Impl
void EnableAsciiIpv4Impl(Ptr< OutputStreamWrapper > stream, std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename)
Enable ascii trace output on the Ipv4 and interface pair specified by a global node-id (of a previous...
Definition internet-trace-helper.cc:281

ns3::AsciiTraceHelperForIpv4::EnableAsciiIpv4All
void EnableAsciiIpv4All(std::string prefix)
Enable ascii trace output on all Ipv4 and interface pairs existing in the set of all nodes created in...
Definition internet-trace-helper.cc:239

ns3::AsciiTraceHelperForIpv4::EnableAsciiIpv4
void EnableAsciiIpv4(std::string prefix, Ptr< Ipv4 > ipv4, uint32_t interface, bool explicitFilename=false)
Enable ascii trace output on the indicated Ipv4 and interface pair.
Definition internet-trace-helper.cc:107

ns3::AsciiTraceHelperForIpv4::EnableAsciiIpv4Internal
virtual void EnableAsciiIpv4Internal(Ptr< OutputStreamWrapper > stream, std::string prefix, Ptr< Ipv4 > ipv4, uint32_t interface, bool explicitFilename)=0
Enable ascii trace output on the indicated Ipv4 and interface pair.

ns3::AsciiTraceHelperForIpv6::EnableAsciiIpv6All
void EnableAsciiIpv6All(std::string prefix)
Enable ascii trace output on all Ipv6 and interface pairs existing in the set of all nodes created in...
Definition internet-trace-helper.cc:519

ns3::AsciiTraceHelperForIpv6::EnableAsciiIpv6
void EnableAsciiIpv6(std::string prefix, Ptr< Ipv6 > ipv6, uint32_t interface, bool explicitFilename=false)
Enable ascii trace output on the indicated Ipv6 and interface pair.
Definition internet-trace-helper.cc:387

ns3::AsciiTraceHelperForIpv6::EnableAsciiIpv6Internal
virtual void EnableAsciiIpv6Internal(Ptr< OutputStreamWrapper > stream, std::string prefix, Ptr< Ipv6 > ipv6, uint32_t interface, bool explicitFilename)=0
Enable ascii trace output on the indicated Ipv6 and interface pair.

ns3::AsciiTraceHelperForIpv6::EnableAsciiIpv6Impl
void EnableAsciiIpv6Impl(Ptr< OutputStreamWrapper > stream, std::string prefix, uint32_t nodeid, uint32_t interface, bool explicitFilename)
Enable ascii trace output on the Ipv6 and interface pair specified by a global node-id (of a previous...
Definition internet-trace-helper.cc:560

ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition ipv4.h:69

ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition ipv4-interface-container.h:45

ns3::Ipv4InterfaceContainer::End
Iterator End() const
Get an iterator which indicates past-the-last Node in the container.
Definition ipv4-interface-container.cc:37

ns3::Ipv4InterfaceContainer::Begin
Iterator Begin() const
Get an iterator which refers to the first pair in the container.
Definition ipv4-interface-container.cc:31

ns3::Ipv6
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition ipv6.h:71

ns3::Ipv6InterfaceContainer
Keep track of a set of IPv6 interfaces.
Definition ipv6-interface-container.h:29

ns3::Ipv6InterfaceContainer::End
Iterator End() const
Get an iterator which indicates past-the-last Node in the container.
Definition ipv6-interface-container.cc:32

ns3::Ipv6InterfaceContainer::Begin
Iterator Begin() const
Get an iterator which refers to the first pair in the container.
Definition ipv6-interface-container.cc:26

ns3::Names::Find
static Ptr< T > Find(std::string path)
Given a name path string, look to see if there's an object in the system with that associated to it.
Definition names.h:443

ns3::NodeContainer
keep track of a set of node pointers.
Definition node-container.h:29

ns3::NodeContainer::End
Iterator End() const
Get an iterator which indicates past-the-last Node in the container.
Definition node-container.cc:55

ns3::NodeContainer::GetGlobal
static NodeContainer GetGlobal()
Create a NodeContainer that contains a list of all nodes created through NodeContainer::Create() and ...
Definition node-container.cc:17

ns3::NodeContainer::Begin
Iterator Begin() const
Get an iterator which refers to the first Node in the container.
Definition node-container.cc:49

ns3::PcapHelperForIpv4::EnablePcapIpv4Internal
virtual void EnablePcapIpv4Internal(std::string prefix, Ptr< Ipv4 > ipv4, uint32_t interface, bool explicitFilename)=0
Enable pcap output the indicated Ipv4 and interface pair.

ns3::PcapHelperForIpv4::EnablePcapIpv4
void EnablePcapIpv4(std::string prefix, Ptr< Ipv4 > ipv4, uint32_t interface, bool explicitFilename=false)
Enable pcap output the indicated Ipv4 and interface pair.
Definition internet-trace-helper.cc:28

ns3::PcapHelperForIpv4::EnablePcapIpv4All
void EnablePcapIpv4All(std::string prefix)
Enable pcap output on all Ipv4 and interface pairs existing in the set of all nodes created in the si...
Definition internet-trace-helper.cc:73

ns3::PcapHelperForIpv6::EnablePcapIpv6All
void EnablePcapIpv6All(std::string prefix)
Enable pcap output on all Ipv6 and interface pairs existing in the set of all nodes created in the si...
Definition internet-trace-helper.cc:353

ns3::PcapHelperForIpv6::EnablePcapIpv6
void EnablePcapIpv6(std::string prefix, Ptr< Ipv6 > ipv6, uint32_t interface, bool explicitFilename=false)
Enable pcap output the indicated Ipv6 and interface pair.
Definition internet-trace-helper.cc:308

ns3::PcapHelperForIpv6::EnablePcapIpv6Internal
virtual void EnablePcapIpv6Internal(std::string prefix, Ptr< Ipv6 > ipv6, uint32_t interface, bool explicitFilename)=0
Enable pcap output the indicated Ipv6 and interface pair.

ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition mpi-test-fixtures.h:37

uint32_t

NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191

internet-trace-helper.h

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.