internet.EnablePcap ("tcp-large-transfer");

#include "ns3/config.h"

std::vector<InternetStackHelper::Trace> InternetStackHelper::m_traces;

void

InternetStackHelper::EnablePcap (std::string filename)

{

  m_filename = filename;

  Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Tx",

                              MakeCallback (&InternetStackHelper::LogTxIp, this));

  Config::Connect ("/NodeList/*/$ns3::Ipv4L3Protocol/Rx",

                              MakeCallback (&InternetStackHelper::LogRxIp, this));

}

uint32_t

InternetStackHelper::GetNodeIndex (std::string context) const

{

  std::string::size_type pos;

  pos = context.find ("/NodeList/");

  NS_ASSERT (pos == 0);

  std::string::size_type afterNodeIndex = context.find ("/", 11);

  NS_ASSERT (afterNodeIndex != std::string::npos);

  std::string index = context.substr (10, afterNodeIndex - 10);

  std::istringstream iss;

  iss.str (index);

  uint32_t nodeIndex;

  iss >> nodeIndex;

  return nodeIndex;

} 

void

InternetStackHelper::LogTxIp (std::string context, Ptr<const Packet> packet, uint32_t interfaceIndex)

{

  Ptr<PcapWriter> writer = GetStream (GetNodeIndex (context), interfaceIndex);

  writer->WritePacket (packet);

}

void

InternetStackHelper::LogRxIp (std::string context, Ptr<const Packet> packet, uint32_t interfaceIndex)

{

  Ptr<PcapWriter> writer = GetStream (GetNodeIndex (context), interfaceIndex);

  writer->WritePacket (packet);

}

Ptr<PcapWriter>

InternetStackHelper::GetStream (uint32_t nodeId, uint32_t interfaceId)

{

  for (std::vector<Trace>::iterator i = m_traces.begin ();

       i != m_traces.end (); i++)

  {

    if (i->nodeId == nodeId &&

        i->interfaceId == interfaceId)

    {

      return i->writer;

    }

  }

  InternetStackHelper::Trace trace;

  trace.nodeId = nodeId;

  trace.interfaceId = interfaceId;

  trace.writer = Create<PcapWriter> ();

  std::ostringstream oss;

  oss << m_filename << ".pcap-" << nodeId << "-" << interfaceId;

  trace.writer->Open (oss.str ());

  trace.writer->WriteIpHeader ();

  m_traces.push_back (trace);

  return trace.writer;

}

#include "net-device-container.h"

#include "ns3/pcap-writer.h"

#include "ns3/packet.h"

  /**

   * \param filename filename prefix to use for pcap files.

   *

   * Enable pcap output on each device which is of the

   * ns3::PointToPointNetDevice type

   */

  void EnablePcap (std::string filename);

private:

  void LogRxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);

  void LogTxIp (std::string context, Ptr<const Packet> packet, uint32_t deviceId);

  Ptr<PcapWriter> GetStream (uint32_t nodeId, uint32_t interfaceId);

  struct Trace {

    uint32_t nodeId;

    uint32_t interfaceId;

    Ptr<PcapWriter> writer;

  };

  std::string m_filename;

  uint32_t GetNodeIndex (std::string context) const;

  static std::vector<Trace> m_traces;