Attachment #308 for bug #416

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





PcapWriter::~PcapWriter ()
{
  Close();
    {
      m_writer->close ();
    }
  delete m_writer;
  m_writer = 0;
}

{
  m_writer = new std::ofstream ();
  m_writer->open (name.c_str ());
}

void
PcapWriter::Close ()
{
  if (m_writer != 0 && m_writer->is_open ())
    {
      m_writer->close ();
    }
}

void 

(-)a/src/common/pcap-writer.h (+5 lines)

Lines 50-55 public:	Link Here

  void Open (std::string const &name);

  void Open (std::string const &name);

/**

/**

   * Close file.

*/

  void Close (void);

/**

   * Write a pcap header in the output file which specifies

   * Write a pcap header in the output file which specifies

   * that the content of the file will be Packets with

   * that the content of the file will be Packets with

   * Ethernet/LLC/SNAP encapsulation. This method should

   * Ethernet/LLC/SNAP encapsulation. This method should





namespace ns3 {

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

CsmaHelper::CsmaHelper ()
{
  m_queueFactory.SetTypeId ("ns3::DropTailQueue");
  m_deviceFactory.SetTypeId ("ns3::CsmaNetDevice");
  m_channelFactory.SetTypeId ("ns3::CsmaChannel");
}

void
CsmaHelper::Cleanup (void)
{
  uint32_t illegal = std::numeric_limits<uint32_t>::max();
  
  for (std::vector<Trace>::iterator i = m_traces.begin ();
       i != m_traces.end (); i++)
  { 
    i->nodeId = illegal;
    i->deviceId = illegal;
    i->writer->Close();
    i->writer = 0;
  }
  m_traces.clear ();
}

void 

  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::CsmaNetDevice/TxQueue/Enqueue";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&CsmaHelper::EnqueueEvent, pcap));
  // Store pcap pointer for later destruction
  CsmaHelper::Trace trace;
  trace.nodeId = nodeid;
  trace.deviceId = deviceid;
  trace.writer = pcap;
  m_traces.push_back (trace);
}
void 
CsmaHelper::EnablePcap (std::string filename, NetDeviceContainer d)

void
CsmaHelper::EnablePcapAll (std::string filename)
{
  Simulator::ScheduleDestroy (&CsmaHelper::Cleanup);

  EnablePcap (filename, NodeContainer::GetGlobal ());
}


  *os << path << " " << *packet << std::endl;
}

Ptr<PcapWriter>
CsmaHelper::GetStream (uint32_t nodeId, uint32_t deviceId)
{
  for (std::vector<Trace>::iterator i = m_traces.begin ();
       i != m_traces.end (); i++)
    {
      if (i->nodeId == nodeId &&
          i->deviceId == deviceId)
        {
          return i->writer;
        }  
    }
  return 0;
}

} // namespace ns3

(-)a/src/helper/csma-helper.h (+10 lines)

Lines 240-245 public:	Link Here

240

                    NetDeviceContainer& hubDevices, NetDeviceContainer& spokeDevices);

240

                    NetDeviceContainer& hubDevices, NetDeviceContainer& spokeDevices);

241

242

private:

242

private:

243

  static void Cleanup (void);

244

243

  Ptr<NetDevice> InstallPriv (Ptr<Node> node, Ptr<CsmaChannel> channel) const;

245

  Ptr<NetDevice> InstallPriv (Ptr<Node> node, Ptr<CsmaChannel> channel) const;

244

246

245

  static void RxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet);

247

  static void RxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet);

Lines 251-256 private:	Link Here

251

  ObjectFactory m_queueFactory;

253

  ObjectFactory m_queueFactory;

252

  ObjectFactory m_deviceFactory;

254

  ObjectFactory m_deviceFactory;

253

  ObjectFactory m_channelFactory;

255

  ObjectFactory m_channelFactory;

256

257

  static Ptr<PcapWriter> GetStream (uint32_t nodeId, uint32_t deviceId);

258

  struct Trace {

259

    uint32_t nodeId;

260

    uint32_t deviceId;

261

    Ptr<PcapWriter> writer;

262

};

263

  static std::vector<Trace> m_traces;

254

};

264

};

255

265

256

266




#include "ns3/config.h"
#include "ns3/packet.h"


namespace ns3 {

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

PointToPointHelper::PointToPointHelper ()
{
  m_queueFactory.SetTypeId ("ns3::DropTailQueue");
  m_deviceFactory.SetTypeId ("ns3::PointToPointNetDevice");
  m_channelFactory.SetTypeId ("ns3::PointToPointChannel");
}

void
PointToPointHelper::Cleanup (void)
{
  uint32_t illegal = std::numeric_limits<uint32_t>::max();
  
  for (std::vector<Trace>::iterator i = m_traces.begin ();
       i != m_traces.end (); i++)
  { 
    i->nodeId = illegal;
    i->deviceId = illegal;
    i->writer->Close(); 
    i->writer = 0;
  }
  m_traces.clear ();
}

void 

  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::PointToPointNetDevice/TxQueue/Enqueue";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&PointToPointHelper::EnqueueEvent, pcap));
  // Store pcap pointer for later destruction
  PointToPointHelper::Trace trace;
  trace.nodeId = nodeid;
  trace.deviceId = deviceid;
  trace.writer = pcap;
  m_traces.push_back (trace);
}
void 
PointToPointHelper::EnablePcap (std::string filename, NetDeviceContainer d)

void
PointToPointHelper::EnablePcapAll (std::string filename)
{
  Simulator::ScheduleDestroy (&PointToPointHelper::Cleanup);

  EnablePcap (filename, NodeContainer::GetGlobal ());
}


  *os << path << " " << *packet << std::endl;
}

Ptr<PcapWriter>
PointToPointHelper::GetStream (uint32_t nodeId, uint32_t deviceId)
{
  for (std::vector<Trace>::iterator i = m_traces.begin ();
       i != m_traces.end (); i++)
    {
      if (i->nodeId == nodeId &&
          i->deviceId == deviceId)
        {
          return i->writer;
        }  
    }
  return 0;
}

} // namespace ns3

(-)a/src/helper/point-to-point-helper.h (+10 lines)

Lines 208-213 public:	Link Here

208

                    NetDeviceContainer& hubDevices, NetDeviceContainer& spokeDevices);

208

                    NetDeviceContainer& hubDevices, NetDeviceContainer& spokeDevices);

209

210

private:

210

private:

211

  static void Cleanup (void);

212

211

  void EnablePcap (Ptr<Node> node, Ptr<NetDevice> device, Ptr<Queue> queue);

213

  void EnablePcap (Ptr<Node> node, Ptr<NetDevice> device, Ptr<Queue> queue);

212

  void EnableAscii (Ptr<Node> node, Ptr<NetDevice> device);

214

  void EnableAscii (Ptr<Node> node, Ptr<NetDevice> device);

213

  static void RxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet);

215

  static void RxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet);

Lines 219-224 private:	Link Here

219

  ObjectFactory m_queueFactory;

221

  ObjectFactory m_queueFactory;

220

  ObjectFactory m_channelFactory;

222

  ObjectFactory m_channelFactory;

221

  ObjectFactory m_deviceFactory;

223

  ObjectFactory m_deviceFactory;

224

225

  static Ptr<PcapWriter> GetStream (uint32_t nodeId, uint32_t deviceId);

226

  struct Trace {

227

    uint32_t nodeId;

228

    uint32_t deviceId;

229

    Ptr<PcapWriter> writer;

230

};

231

  static std::vector<Trace> m_traces;

222

};

232

};

223

233

224

234

Return to bug 416