Attachment #830 for bug #872

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

(-)a/examples/tutorial/sixth.cc (-1 / +1 lines)

Lines 219-225	Link Here

219

  ns3TcpSocket->TraceConnectWithoutContext ("CongestionWindow", MakeBoundCallback (&CwndChange, stream));

219

  ns3TcpSocket->TraceConnectWithoutContext ("CongestionWindow", MakeBoundCallback (&CwndChange, stream));

220

221

  PcapHelper pcapHelper;

221

  PcapHelper pcapHelper;

222

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile ("sixth.pcap", "w", PcapHelper::DLT_PPP);

222

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile ("sixth.pcap", std::ios::out, PcapHelper::DLT_PPP);

223

  devices.Get (1)->TraceConnectWithoutContext("PhyRxDrop", MakeBoundCallback (&RxDrop, file));

223

  devices.Get (1)->TraceConnectWithoutContext("PhyRxDrop", MakeBoundCallback (&RxDrop, file));

224

225

  Simulator::Stop (Seconds(20));

225

  Simulator::Stop (Seconds(20));




// Some utility functions for the tests.
// ===========================================================================

static uint16_t
Swap (uint16_t val)
{
  return ((val >> 8) & 0x00ff) | ((val << 8) & 0xff00);
}

static uint32_t 
Swap (uint32_t val)
{
  return ((val >> 24) & 0x000000ff) | ((val >> 8) & 0x0000ff00) | ((val << 8) & 0x00ff0000) | ((val << 24) & 0xff000000);
}

static bool
CheckFileExists (std::string filename)
{
  FILE * p = fopen (filename.c_str (), "rb");

}


static bool
CheckFileLength (std::string filename, uint64_t sizeExpected)
{
  FILE * p = fopen (filename.c_str (), "rb");

};

WriteModeCreateTestCase::WriteModeCreateTestCase ()
  : TestCase ("Check to see that PcapFile::Open with mode std::ios::out works")
{
}


  // Opening a new file in write mode should result in an empty file of the
  // given name.
  //
  f.Open (m_testFilename, std::ios::out);

  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << ", \"w\") returns error");
  f.Close ();

  NS_TEST_ASSERT_MSG_EQ (CheckFileExists (m_testFilename), true, 
                         "Open (" << m_testFilename << ", \"std::ios::out\") does not create file");
  NS_TEST_ASSERT_MSG_EQ (CheckFileLength (m_testFilename, 0), true,
                         "Open (" << m_testFilename << ", \"std::ios::out\") does not result in an empty file");

  //
  // Calling Init() on a file created with "std::ios::out" should result in a file just 
  // long enough to contain the pcap file header.
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");

  f.Init (1234, 5678, 7);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (1234, 5678, 7) returns error");

  f.Close ();


  // Opening an existing file in write mode should result in that file being
  // emptied.
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");

  f.Close ();


  //
  // Initialize the file again.
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, 
                         "Open (" << m_testFilename << ", \"w\") returns error");

  f.Init (1234, 5678, 7);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (1234, 5678, 7) returns error");

  //
  // Now we should be able to write to it since it was opened in std::ios::out mode.
  // This is just a permissions check so we don't actually look at the 
  // data.
  //
  uint8_t buffer[128];
  memset(buffer, 0, sizeof(buffer));
  f.Write (0, 0, buffer, 128);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Write (write-only-file " << m_testFilename << 
                         ") returns error");

  return false;
}

};

ReadModeCreateTestCase::ReadModeCreateTestCase ()
  : TestCase ("Check to see that PcapFile::Open with mode \"std::ios::in\" works")
{
}


  //
  // Opening a non-existing file in read mode should result in an error.
  //
  f.Open (m_testFilename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), true, "Open (non-existing-filename " << m_testFilename << 
                         ", \"std::ios::in\") does not return error");
  f.Close ();
  f.Clear ();
  NS_TEST_ASSERT_MSG_EQ (CheckFileExists (m_testFilename), false, "Open (" << m_testFilename << 
                         ", \"std::ios::in\") unexpectedly created a file");

  //
  // Okay, now create an uninitialized file using previously tested operations
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (filename, \"std::ios::out\") returns error");
  f.Close ();

  //
  // Opening this file should result in an error since it has no pcap file header.
  //
  f.Open (m_testFilename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), true, "Open (non-initialized-filename " << m_testFilename << 
                         ", \"std::ios::in\") does not return error");
  f.Close ();
  f.Clear ();

  //
  // Okay, now open that non-initialized file in write mode and initialize it
  // Note that we open it in write mode to initialize it.
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");

  f.Init (1234, 5678, 7);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (1234, 5678, 7) returns error");
  f.Close ();

  //
  // Opening this file should now work since it has a pcap file header.
  //
  f.Open (m_testFilename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (initialized-filename " << m_testFilename << 
                         ", \"std::ios::in\") returns error");

  //
  // Now we should not be able to write to it since it was opened in "r" mode
  // even if it has been initialized..
  //
  uint8_t buffer[128];
  f.Write (0, 0, buffer, 128);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), true, "Write (read-only-file " << m_testFilename << 
                         ") does not return error");
  f.Close ();
  f.Clear ();

  return false;
}

#if 0
// ===========================================================================
// Test case to make sure that the Pcap File Object can open an existing pcap
// file for appending.

};

AppendModeCreateTestCase::AppendModeCreateTestCase ()
  : TestCase ("Check to see that PcapFile::Open with mode \"std::ios::app\" works")
{
}


  //
  // Opening a non-existing file in append mode should result in an error.
  //
  f.Open (m_testFilename, std::ios::out | std::ios::app);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), true, "Open (non-existing-filename " << m_testFilename << 
                         ", \"std::ios::app\") does not return error");
  f.Close ();
  f.Clear ();

  NS_TEST_ASSERT_MSG_EQ (CheckFileExists (m_testFilename), false, 
                         "Open (" << m_testFilename << ", \"std::ios::app\") unexpectedly created a file");

  //
  // Okay, now create an uninitialized file using previously tested operations
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");
  f.Close ();

  //
  // Opening this file should result in an error since it has no pcap file header.
  //
  f.Open (m_testFilename, std::ios::out | std::ios::app);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), true, "Open (non-initialized-filename " << m_testFilename << 
                         ", \"std::ios::app\") does not return error");
  f.Close ();
  f.Clear ();

  //
  // Okay, now open that non-initialized file in write mode and initialize it.
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (non-initialized-filename " << m_testFilename << 
                         ", \"std::ios::out\") returns error");

  f.Init (1234, 5678, 7);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (1234, 5678, 7) returns error");
  f.Close ();

  //
  // Opening this file should now work since it has a pcap file header.
  //
  f.Open (m_testFilename, std::ios::out | std::ios::app);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (initialized-filename " << m_testFilename << 
                         ", \"std::ios::app\") returns error");

  //
  // We should be able to write to it since it was opened in "std::ios::app" mode.
  //
  uint8_t buffer[128];
  memset(buffer, 0, sizeof(buffer));
  f.Write (0, 0, buffer, 128);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Write (append-mode-file " << m_testFilename << ") returns error");

  f.Close ();

  return false;
}
#endif

// ===========================================================================
// Test case to make sure that the Pcap File Object can write out correct pcap

  //
  // Create an uninitialized file using previously tested operations
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");
  
  //
  // Initialize the pcap file header.
  //
  f.Init (1234, 5678, 7);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, 
                         "Init (1234, 5678, 7) returns error");
  f.Close ();


  // automagically fixed up when using a PcapFile to read the values, so we 
  // don't have to do anything special here.
  //
  f.Open (m_testFilename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (existing-initialized-file " << m_testFilename << 
                         ", \"std::ios::in\") returns error");

  NS_TEST_ASSERT_MSG_EQ (f.GetMagic (), 0xa1b2c3d4, "Read back magic number incorrectly");
  NS_TEST_ASSERT_MSG_EQ (f.GetVersionMajor (), 2, "Read back version major incorrectly");

  NS_TEST_ASSERT_MSG_EQ (f.GetSigFigs (), 0, "Read back sig figs incorrectly");
  NS_TEST_ASSERT_MSG_EQ (f.GetSnapLen (), 5678, "Read back snap len incorrectly");
  NS_TEST_ASSERT_MSG_EQ (f.GetDataLinkType (), 1234, "Read back data link type incorrectly");
  f.Close ();
  
  //
  // Re-open the file to erase its contents.
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");

  //
  // Initialize the pcap file header, turning on swap mode manually to force

  // a no-op and we're always writing foreign-endian files.  In that case, 
  // this test case is really just a duplicate of the previous.
  //
  f.Init (1234, 5678, 7, true);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (1234, 5678, 7) returns error");
  f.Close ();

  //

  // machine is writing out a big-endian file by default, but we can't do that 
  // since it breaks regression testing.
  //
  f.Open (m_testFilename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (existing-initialized-file " << m_testFilename << 
                         ", \"std::ios::in\") returns error");

  NS_TEST_ASSERT_MSG_EQ (f.GetSwapMode (), true, "Byte-swapped file not correctly indicated");


  //
  // Create an uninitialized file using previously tested operations
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");

  //
  // Initialize the pcap file header.
  //
  f.Init (37, 43, -7);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (37, 43, -7) returns error");

  //
  // Initialize a buffer with a counting pattern to check the data later.

  // mode.  The packet data written should be limited to 43 bytes in length 
  // by the Init() call above.
  //
  f.Write (1234, 5678, bufferOut, 128);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Write (write-only-file " << m_testFilename << ") returns error");
  f.Close ();

  //

  // Let's see if the PcapFile object can figure out how to do the same thing and
  // correctly read in a packet.
  //
  f.Open (m_testFilename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::in\") of existing good file returns error");

  uint32_t tsSec, tsUsec, inclLen, origLen, readLen;

  f.Read (bufferIn, sizeof(bufferIn), tsSec, tsUsec, inclLen, origLen, readLen);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Read() of known good packet returns error");
  NS_TEST_ASSERT_MSG_EQ (tsSec, 1234, "Incorrectly read seconds timestap from known good packet");
  NS_TEST_ASSERT_MSG_EQ (tsUsec, 5678, "Incorrectly read microseconds timestap from known good packet");
  NS_TEST_ASSERT_MSG_EQ (inclLen, 43, "Incorrectly read included length from known good packet");
  NS_TEST_ASSERT_MSG_EQ (origLen, 128, "Incorrectly read original length from known good packet");
  NS_TEST_ASSERT_MSG_EQ (readLen, 43, "Incorrectly constructed actual read length from known good packet given buffer size");
  f.Close ();

  //
  // Did the data come back correctly?

  //
  // Open the file in write mode to clear the data.
  //
  f.Open (m_testFilename, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::out\") returns error");

  //
  // Initialize the pcap file header, forcing the object into swap mode.
  //
  f.Init (37, 43, -7, true);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (37, 43, -7) returns error");

  //
  // Now we should be able to write a packet to it since it was opened in "w" 
  // mode.  The packet data written should be limited to 43 bytes in length 
  // by the Init() call above.
  //
  f.Write (1234, 5678, bufferOut, 128);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Write (write-only-file " << m_testFilename << ") returns error");
  f.Close ();

  //

  // correctly read in a packet.  The record header info should come back to us
  // swapped back into correct form.
  //
  f.Open (m_testFilename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << m_testFilename << 
                         ", \"std::ios::in\") of existing good file returns error");

  f.Read (bufferIn, sizeof(bufferIn), tsSec, tsUsec, inclLen, origLen, readLen);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Read() of known good packet returns error");
  NS_TEST_ASSERT_MSG_EQ (tsSec, 1234, "Incorrectly read seconds timestap from known good packet");
  NS_TEST_ASSERT_MSG_EQ (tsUsec, 5678, "Incorrectly read microseconds timestap from known good packet");
  NS_TEST_ASSERT_MSG_EQ (inclLen, 43, "Incorrectly read included length from known good packet");

  //
  //
  std::string filename = NS_TEST_SOURCEDIR + "known.pcap";
  f.Open (filename, std::ios::in);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << filename << 
                         ", \"std::ios::in\") returns error");
 
  //
  // We are going to read out the file header and all of the packets to make 


  for (uint32_t i = 0; i < N_KNOWN_PACKETS; ++i, ++p)
    {
      f.Read (data, sizeof(data), tsSec, tsUsec, inclLen, origLen, readLen);
      NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Read() of known good pcap file returns error");
      NS_TEST_ASSERT_MSG_EQ (tsSec, p->tsSec, "Incorrectly read seconds timestap from known good pcap file");
      NS_TEST_ASSERT_MSG_EQ (tsUsec, p->tsUsec, "Incorrectly read microseconds timestap from known good pcap file");
      NS_TEST_ASSERT_MSG_EQ (inclLen, p->inclLen, "Incorrectly read included length from known good packet");

  // The file should now be at EOF since we've read all of the packets.
  // Another packet read should return an error.
  //
  f.Read (data, 1, tsSec, tsUsec, inclLen, origLen, readLen);
  NS_TEST_ASSERT_MSG_EQ (f.Eof (), true, "Read() of known good pcap file at EOF does not return error");

  f.Close ();


  std::string filename2 = "different.pcap";
  PcapFile f;
  
  f.Open (filename2, std::ios::out);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Open (" << filename2 << ", \"std::ios::out\") returns error");
  f.Init (1, N_PACKET_BYTES);
  NS_TEST_ASSERT_MSG_EQ (f.Fail (), false, "Init (1, " << N_PACKET_BYTES << ") returns error");
  
  for (uint32_t i = 0; i < N_KNOWN_PACKETS; ++i)
    {
      PacketEntry const & p = knownPackets[i];
      
      f.Write (p.tsSec, p.tsUsec, (uint8_t const *)p.data, p.origLen);
      NS_TEST_EXPECT_MSG_EQ (f.Fail (), false, "Write must not fail");
    }
  f.Close ();


{
  AddTestCase (new WriteModeCreateTestCase);
  AddTestCase (new ReadModeCreateTestCase);
  //AddTestCase (new AppendModeCreateTestCase);
  AddTestCase (new FileHeaderTestCase);
  AddTestCase (new RecordHeaderTestCase);
  AddTestCase (new ReadFileTestCase);




  Close ();
}


bool 
PcapFileWrapper::Fail (void) const
{
  return m_file.Fail ();
}
bool 
PcapFileWrapper::Eof (void) const
{
  return m_file.Eof ();
}
void 
PcapFileWrapper::Clear (void)
{
  m_file.Clear ();
}

void
PcapFileWrapper::Close (void)
{
  m_file.Close ();
}

void
PcapFileWrapper::Open (std::string const &filename, std::ios::openmode mode)
{
  m_file.Open (filename, mode);
}

void
PcapFileWrapper::Init (uint32_t dataLinkType, uint32_t snapLen, int32_t tzCorrection)
{
  //

  //
  if (snapLen != std::numeric_limits<uint32_t>::max ())
    {
      m_file.Init (dataLinkType, snapLen, tzCorrection);
    } 
  else
    {
      m_file.Init (dataLinkType, m_snapLen, tzCorrection);
    } 

  //
  // Quiet the compiler
  //
  return true;
}

void
PcapFileWrapper::Write (Time t, Ptr<const Packet> p)
{
  uint8_t buffer[PcapFile::SNAPLEN_DEFAULT];

  uint64_t current = t.GetMicroSeconds ();
  uint64_t s = current / 1000000;
  uint64_t us = current % 1000000;

  m_file.Write (s, us, p);
  p->CopyData (buffer, bufferSize);
  bool rc = m_file.Write (s, us, buffer, bufferSize);
  return rc;
}

void
PcapFileWrapper::Write (Time t, Header &header, Ptr<const Packet> p)
{
  uint8_t buffer[PcapFile::SNAPLEN_DEFAULT];

  uint64_t current = t.GetMicroSeconds ();
  uint64_t s = current / 1000000;
  uint64_t us = current % 1000000;

  m_file.Write (s, us, header, p);
  uint32_t headerSize = header.GetSerializedSize ();
  uint32_t packetSize = p->GetSize ();
  uint32_t bufferSize = headerSize + packetSize;

  headerBuffer.AddAtStart (headerSize);
  header.Serialize (headerBuffer.Begin ());

  headerBuffer.Begin ().Read (buffer, headerSize);
  p->CopyData (&buffer[headerSize], packetSize);
  bool rc = m_file.Write (s, us, buffer, bufferSize);

  return rc;
}

void
PcapFileWrapper::Write (Time t, uint8_t const *buffer, uint32_t length)
{
  uint64_t current = t.GetMicroSeconds ();
  uint64_t s = current / 1000000;
  uint64_t us = current % 1000000;

  m_file.Write (s, us, buffer, length);
}

uint32_t





#include <string.h>
#include <limits>
#include <fstream>
#include "ns3/ptr.h"
#include "ns3/packet.h"
#include "ns3/nstime.h"

  PcapFileWrapper ();
  ~PcapFileWrapper ();


  /**
   * \return true if the 'fail' bit is set in the underlying iostream, false otherwise.
   */
  bool Fail (void) const;
  /**
   * \return true if the 'eof' bit is set in the underlying iostream, false otherwise.
   */
  bool Eof (void) const;
  /**
   * Clear all state bits of the underlying iostream.
   */
  void Clear (void);

  /**
   * Create a new pcap file or open an existing pcap file.  Semantics are
   * similar to the stdc++ io stream classes.
   *        any packet data.  The file seek position indicator is set to point 
   *        to the beginning of the file on exit since there will be no pcap
   *        header.
   *
   * "a":   Append to an existing file. This mode allows for adding packet data
   *        to the end of an existing pcap file.  The file must exist and have a
   *        valid pcap header written (N.B. this is different from standard fopen
   *        semantics).  The file seek position indicator is set to point 
   *        to the end of the file on exit.
   *
   * "r+":  Open a file for update -- both reading and writing. The file must 
   *        exist.  The pcap header is assumed to have been written to the 
   *        file and will be read and checked.  The file seek position indicator
   *        is set to point to the first packet on exit.
   *
   * "w+":  Create an empty file for both reading and writing.  If a file with
   *        the same name already exists, its content is erased and the file is 
   *        treated as a new empty pcap file.  Since this new file will not have
   *        a pcap header, the caller is responsible for calling Init before 
   *        saving any packet data.  On exit, the file seek position indicator is
   *        set to point to the beginning of the file.
   *
   * "a+"   Open a file for reading and appending.  The file must exist and have a
   *        valid pcap header written (N.B. this is different from standard fopen
   *        semantics).  The file seek position indicator is set to point 
   *        to the end of the file on exit.  Existing content is preserved.
   * \endverbatim
   *
   * Since a pcap file is always a binary file, the file type is automatically 
   * selected as a binary file (fstream::binary is automatically ored with the mode
   * field).
   *
   * \param filename String containing the name of the file.
   *
   * \param mode String containing the access mode for the file.
   *
   * \returns Error indication that should be interpreted as, "did an error 
   * happen"?  That is, the method returns false if the open succeeds, true 
   * otherwise.  The errno variable will be set by the OS to to provide a 
   * more descriptive failure indication.
   */
  void Open (std::string const &filename, std::ios::openmode mode);

  /**
   * Close the underlying pcap file.

   * time zone from UTC/GMT.  For example, Pacific Standard Time in the US is
   * GMT-8, so one would enter -8 for that correction.  Defaults to 0 (UTC).
   *
   * \return false if the open succeeds, true otherwise.
   *
   * \warning Calling this method on an existing file will result in the loss
   * any existing data.
   */
  void Init (uint32_t dataLinkType, 
             uint32_t snapLen = std::numeric_limits<uint32_t>::max (), 
             int32_t tzCorrection = PcapFile::ZONE_DEFAULT);


   * \param t Packet timestamp as ns3::Time.
   * \param p Packet to write to the pcap file.
   * 
   * \return true on error, false otherwise
   */
  void Write (Time t, Ptr<const Packet> p);

  /**
   * \brief Write the provided header along with the packet to the pcap file.

   * \param header The Header to prepend to the packet.
   * \param p Packet to write to the pcap file.
   * 
   * \return true on error, false otherwise
   */
  void Write (Time t, Header &header, Ptr<const Packet> p);

  /**
   * \brief Write the provided data buffer to the pcap file.

   * \param buffer The buffer to write.
   * \param length The size of the buffer.
   * 
   * \return true on error, false otherwise
   */
  void Write (Time t, uint8_t const *buffer, uint32_t length);

  /*
   * \brief Returns the magic number of the pcap file as defined by the magic_number




 */

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include "ns3/assert.h"
#include "ns3/packet.h"
#include "ns3/fatal-error.h"
#include "ns3/header.h"
#include "ns3/buffer.h"
#include "pcap-file.h"
//
// This file is used as part of the ns-3 test framework, so please refrain from 

const int32_t  SIGFIGS_DEFAULT = 0;           /**< Significant figures for timestamps (libpcap doesn't even bother) */

PcapFile::PcapFile ()
  : m_file (),
    m_filePtr (0),
    m_haveFileHeader (false),
    m_swapMode (false)
{}
}

PcapFile::~PcapFile ()
{
  Close ();
}


bool 
PcapFile::Fail (void) const
{
  return m_file.fail ();
}
bool 
PcapFile::Eof (void) const
{
  return m_file.eof ();
}
void 
PcapFile::Clear (void)
{
  m_file.clear ();
}


void
PcapFile::Close (void)
{
  m_file.close ();
    {
      fclose (m_filePtr);
    }
  m_filePtr = 0;
  m_filename = "";
  m_haveFileHeader = false;
}

uint32_t

  to->m_origLen = Swap (from->m_origLen);
}

void
PcapFile::WriteFileHeader (void)
{
  //
  // If we're initializing the file, we need to write the pcap file header
  // at the start of the file.
  //
  m_file.seekp (0, std::ios::beg);
  if (result)
    {
      return true;
    }
 
  //
  // We have the ability to write out the pcap file header in a foreign endian

  // Watch out for memory alignment differences between machines, so write
  // them all individually.
  //
  m_file.write ((const char *)&headerOut->m_magicNumber, sizeof(headerOut->m_magicNumber));
  m_file.write ((const char *)&headerOut->m_versionMajor, sizeof(headerOut->m_versionMajor));
  m_file.write ((const char *)&headerOut->m_versionMinor, sizeof(headerOut->m_versionMinor));
  m_file.write ((const char *)&headerOut->m_zone, sizeof(headerOut->m_zone));
  m_file.write ((const char *)&headerOut->m_sigFigs, sizeof(headerOut->m_sigFigs));
  m_file.write ((const char *)&headerOut->m_snapLen, sizeof(headerOut->m_snapLen));
  m_file.write ((const char *)&headerOut->m_type, sizeof(headerOut->m_type));
  result |= (fwrite (&headerOut->m_snapLen, sizeof(headerOut->m_snapLen), 1, m_filePtr) != 1);
  result |= (fwrite (&headerOut->m_type, sizeof(headerOut->m_type), 1, m_filePtr) != 1);

  //
  // If any of the fwrites above did not succeed in writinging the correct
  // number of objects, result will be nonzero and will indicate an error.
  //
  return result != 0;
}

void
PcapFile::ReadAndVerifyFileHeader (void)
{
  //
  // Pcap file header is always at the start of the file
  //
  m_file.seekg (0, std::ios::beg);
  if (result)
    {
      return true;
    }

  //
  // Watch out for memory alignment differences between machines, so read
  // them all individually.
  //
  m_file.read ((char *)&m_fileHeader.m_magicNumber, sizeof(m_fileHeader.m_magicNumber));
  m_file.read ((char *)&m_fileHeader.m_versionMajor, sizeof(m_fileHeader.m_versionMajor));
  m_file.read ((char *)&m_fileHeader.m_versionMinor, sizeof(m_fileHeader.m_versionMinor));
  m_file.read ((char *)&m_fileHeader.m_zone, sizeof(m_fileHeader.m_zone));
  m_file.read ((char *)&m_fileHeader.m_sigFigs, sizeof(m_fileHeader.m_sigFigs));
  m_file.read ((char *)&m_fileHeader.m_snapLen, sizeof(m_fileHeader.m_snapLen));
  m_file.read ((char *)&m_fileHeader.m_type, sizeof(m_fileHeader.m_type));
  result |= (fread (&m_fileHeader.m_snapLen, sizeof(m_fileHeader.m_snapLen), 1, m_filePtr) != 1);
  result |= (fread (&m_fileHeader.m_type, sizeof(m_fileHeader.m_type), 1, m_filePtr) != 1);

  //
  // If any of the freads above did not succeed in reading the correct number of 
  // objects, result will be nonzero.
  //
  if (result)
    {
      return true;
    }

  //
  // There are four possible magic numbers that can be there.  Normal and byte

  if (m_fileHeader.m_magicNumber != MAGIC && m_fileHeader.m_magicNumber != SWAPPED_MAGIC && 
      m_fileHeader.m_magicNumber != NS_MAGIC && m_fileHeader.m_magicNumber != NS_SWAPPED_MAGIC)
    {
      m_file.setstate (std::ios::failbit);
    }

  //
  // If the magic number is swapped, then we can assume that everything else we read
  // is swapped.
  //
  m_swapMode = (m_fileHeader.m_magicNumber == SWAPPED_MAGIC 
                || m_fileHeader.m_magicNumber == NS_SWAPPED_MAGIC) ? true : false;

  if (m_swapMode)
    {

  //
  if (m_fileHeader.m_versionMajor != VERSION_MAJOR || m_fileHeader.m_versionMinor != VERSION_MINOR)
    {
      m_file.setstate (std::ios::failbit);
    }

  //

  //
  if (m_fileHeader.m_zone < -12 || m_fileHeader.m_zone > 12)
    {
      m_file.setstate (std::ios::failbit);
    }

  if (m_file.fail ())
    {
      m_file.close ();
    }
}

void
PcapFile::Open (std::string const &filename, std::ios::openmode mode)
{
  NS_ASSERT ((mode & std::ios::app) == 0);
  NS_ASSERT (!m_file.fail ());
  //
  Close ();
        
  //
  // All pcap files are binary files, so we just do this automatically.
  //
  mode |= std::ios::binary;

  m_file.open (filename.c_str (), mode);
  if (mode & std::ios::in)
  // we need to have a pcap file header to succeed in some cases; so we need 
  // to process different modes according to our own definitions of the modes.
  //
  // In the case of read modes, we must read, check and save the pcap file
  // header as well as just opening the file.
  //
  // In the case of write modes, we just pass the call on through to the 
  // library.
  //
  // In the case of append modes, we change the semantics to require the
  // given file to exist.  We can't just create a file since we can't make up
  // a pcap file header on our own.
  //
  if (realMode == "rb" || realMode == "r+b")
    {
      // will set the fail bit if file header is invalid.
      ReadAndVerifyFileHeader ();
        {
          return true;
        }
      m_filename = filename;
      return ReadAndVerifyFileHeader ();
    }
  else if (realMode == "wb" || realMode == "w+b")
    {
      m_filePtr = fopen (filename.c_str (), realMode.c_str ());
      if (m_filePtr)
        {
          m_filename = filename;
          return false;
        }
      else
        {
          return true;
        }
    }
  else if (realMode == "ab" || realMode == "a+b")
    {
      //
      // Remember that semantics for append are different here.  We never create
      // a file since we can't make up a pcap file header.  We first have to 
      // open the file in read-only mode and check to see that it exists and
      // read the file header.  If this all works out, then we can go ahead and
      // open the file in append mode and seek to the end (imlicitly).
      //
      m_filePtr = fopen (filename.c_str (), "rb");
      if (m_filePtr == 0)
        {
          return true;
        }

      bool result = ReadAndVerifyFileHeader ();
      if (result == true)
        {
          Close ();
          return true;
        }

      //
      // We have a properly initialized file and have the pcap file header
      // loaded and checked.  This means that the file meets all of the 
      // critera for opening in append mode, but the file is in read-only mode
      // now -- we must close it and open it in the correct mode.
      //
      fclose (m_filePtr);
      m_filePtr = 0;

      m_filePtr = fopen (filename.c_str (), realMode.c_str ());
      if (m_filePtr == 0)
        {
          return true;
        }

      m_filename = filename;
      return false;
    }
  else
    {
      return true;
    }
}

void
PcapFile::Init (uint32_t dataLinkType, uint32_t snapLen, int32_t timeZoneCorrection, bool swapMode)
{
  //

  m_fileHeader.m_snapLen = snapLen;
  m_fileHeader.m_type = dataLinkType;

  m_haveFileHeader = true;

  //
  // We use pcap files for regression testing.  We do byte-for-byte comparisons
  // in those tests to determine pass or fail.  If we allow big endian systems

  //
  m_swapMode = swapMode | bigEndian;

  WriteFileHeader ();
}

uint32_t
PcapFile::WritePacketHeader (uint32_t tsSec, uint32_t tsUsec, uint32_t totalLen)
{
  NS_ASSERT (m_file.good ());
    {
      return true;
    }

  uint32_t inclLen = totalLen > m_fileHeader.m_snapLen ? m_fileHeader.m_snapLen : totalLen;


  // Watch out for memory alignment differences between machines, so write
  // them all individually.
  //
  m_file.write ((const char *)&header.m_tsSec, sizeof(header.m_tsSec));
  m_file.write ((const char *)&header.m_tsUsec, sizeof(header.m_tsUsec));
  m_file.write ((const char *)&header.m_inclLen, sizeof(header.m_inclLen));
  m_file.write ((const char *)&header.m_origLen, sizeof(header.m_origLen));
  return inclLen;
  result |= (fwrite (&header.m_origLen, sizeof(header.m_origLen), 1, m_filePtr) != 1);

  result |= fwrite (data, 1, inclLen, m_filePtr) != inclLen;

  return result != 0;
}

void
PcapFile::Write (uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen)
{
  uint32_t inclLen = WritePacketHeader (tsSec, tsUsec, totalLen);
  m_file.write ((const char *)data, inclLen);
}

void 
PcapFile::Write (uint32_t tsSec, uint32_t tsUsec, Ptr<const Packet> p)
{
  uint32_t inclLen = WritePacketHeader (tsSec, tsUsec, p->GetSize ());
  p->CopyData (&m_file, inclLen);
}

void 
PcapFile::Write (uint32_t tsSec, uint32_t tsUsec, Header &header, Ptr<const Packet> p)
{
  uint32_t headerSize = header.GetSerializedSize ();
  uint32_t totalSize = headerSize + p->GetSize ();
  uint32_t inclLen = WritePacketHeader (tsSec, tsUsec, totalSize);

  Buffer headerBuffer;
  headerBuffer.AddAtStart (headerSize);
  header.Serialize (headerBuffer.Begin ());
  uint32_t toCopy = std::min (headerSize, inclLen);
  headerBuffer.CopyData (&m_file, toCopy);
  inclLen -= toCopy;
  p->CopyData (&m_file, inclLen);
}

void
PcapFile::Read (
  uint8_t * const data, 
  uint32_t maxBytes,

  uint32_t &origLen,
  uint32_t &readLen)
{
  NS_ASSERT (m_file.good ());
    {
      return true;
    }

  PcapRecordHeader header;


  // Watch out for memory alignment differences between machines, so read
  // them all individually.
  //
  m_file.read ((char *)&header.m_tsSec, sizeof(header.m_tsSec));
  m_file.read ((char *)&header.m_tsUsec, sizeof(header.m_tsUsec));
  m_file.read ((char *)&header.m_inclLen, sizeof(header.m_inclLen));
  m_file.read ((char *)&header.m_origLen, sizeof(header.m_origLen));
  result |= (fread (&header.m_inclLen, sizeof(header.m_inclLen), 1, m_filePtr) != 1);
  result |= (fread (&header.m_origLen, sizeof(header.m_origLen), 1, m_filePtr) != 1);

  //
  // If any of the freads above did not succeed in reading the correct number of 
  // objects, result will be nonzero.
  //
  if (result)
    {
      return true;
    }

  if (m_swapMode)
    {

  // for example, to figure out what is going on.
  //
  readLen = maxBytes < header.m_inclLen ? maxBytes : header.m_inclLen;
  m_file.read ((char *)data, readLen);
  if (result)
    {
      return result;
    }

  //
  // To keep the file pointer pointed in the right place, however, we always

  //
  if (readLen < header.m_inclLen)
    {
      m_file.seekg (header.m_inclLen - readLen, std::ios::cur);
      int result = fseek (m_filePtr, pos + header.m_inclLen - readLen, SEEK_SET);
      if (result)
        {
          return true;
        }
    }

  return false;
}

bool

                uint32_t & sec, uint32_t & usec, 
                uint32_t snapLen)
{
  PcapFile pcap1, pcap2;
  pcap1.Open (f1, std::ios::in);
  pcap2.Open (f2, std::ios::in);
  bool bad = pcap1.Fail () || pcap2.Fail ();
  if (bad)
    {
      return true;
      bool err = pcap[i].Open (file, "r");
      if (err)
        {
          // Can't open file
          return true;
        }
    }
  
  uint8_t *data1 = new uint8_t [snapLen] ();
  uint8_t *data2 = new uint8_t [snapLen] ();
  uint32_t tsSec1, tsSec2;
  uint32_t tsUsec1, tsUsec2;
  uint32_t inclLen1, inclLen2;
  uint32_t origLen1, origLen2;
  uint32_t readLen1, readLen2;
  bool diff = false;
  
  while (!pcap1.Eof () && !pcap2.Eof ()
         && !pcap1.Fail () && !pcap2.Fail ())
    {
      pcap1.Read (data1, snapLen, tsSec1, tsUsec1, inclLen1, origLen1, readLen1);
      pcap2.Read (data2, snapLen, tsSec2, tsUsec2, inclLen2, origLen2, readLen2);

      if (tsSec1 != tsSec2 || tsUsec1 != tsUsec2)
      usec = tsUsec[0];
      
      if (err[0] != err[1])
        {
          diff = true; // Read status doesn't match
          break;
        }
      
      if (err[0]) break; // nothing left
      
      if (tsSec[0] != tsSec[1] || tsUsec[0] != tsUsec[1])
        {
          diff = true; // Next packet timestamps do not match
          break;
        }
      
      if (readLen1 != readLen2)
        {
          diff = true; // Packet lengths do not match
          break;
        }
      
      if (std::memcmp(data1, data2, readLen1) != 0)
        {
          diff = true; // Packet data do not match
          break;
        }
    }  
  sec = tsSec1;
  usec = tsUsec1;

  bad = pcap1.Fail () || pcap2.Fail ();
  bool eof = pcap1.Eof () && pcap2.Eof ();
  if (bad && !eof)
    {
      diff = true;
    }

  return diff;
}


(-)a/src/common/pcap-file.h (-59 / +51 lines)

Lines 22-31	Link Here

#define PCAP_FILE_H

#define PCAP_FILE_H

#include <string>

#include <string>

#include <fstream>

#include <stdint.h>

#include <stdint.h>

#include "ns3/ptr.h"

namespace ns3 {

namespace ns3 {

class Packet;

class Header;

/*

/*

 * A class representing a pcap file.  This allows easy creation, writing and

 * A class representing a pcap file.  This allows easy creation, writing and

 * reading of files composed of stored packets; which may be viewed using

 * reading of files composed of stored packets; which may be viewed using

Lines 43-109	Link Here

  ~PcapFile ();

  ~PcapFile ();

/**

/**

   * \return true if the 'fail' bit is set in the underlying iostream, false otherwise.

*/

  bool Fail (void) const;

/**

   * \return true if the 'eof' bit is set in the underlying iostream, false otherwise.

*/

  bool Eof (void) const;

/**

   * Clear all state bits of the underlying iostream.

*/

  void Clear (void);

/**

   * Create a new pcap file or open an existing pcap file.  Semantics are

   * Create a new pcap file or open an existing pcap file.  Semantics are

   * similar to the C standard library function \c fopen, but differ in that

   * similar to the stdc++ io stream classes, but differ in that

   * positions in the file are based on packets not characters.  For example

   * positions in the file are based on packets not characters.  For example

   * if the file is opened for reading, the file position indicator (seek

   * if the file is opened for reading, the file position indicator (seek

   * position) points to the beginning of the first packet in the file, not

   * position) points to the beginning of the first packet in the file, not

   * zero (which would point to the start of the pcap header).

   * zero (which would point to the start of the pcap header).

   * Possible modes are:

   * \verbatim

   * "r":   Open a file for reading.  The file must exist.  The pcap header

   *        is assumed to exist in the file and will be read and checked.

   *        The file seek position indicator is set to point to the first

   *        packet on exit.

   * "w":   Create an empty file for writing. If a file with the same name

   *        already exists its content is erased and the file is treated as a

   *        new empty pcap file.  The file is assumed not to have a pcap

   *        header and the caller is responsible for calling Init before saving

   *        any packet data.  The file seek position indicator is set to point

   *        to the beginning of the file on exit since there will be no pcap

   *        header.

   * "a":   Append to an existing file. This mode allows for adding packet data

   *        to the end of an existing pcap file.  The file must exist and have a

   *        valid pcap header written (N.B. this is different from standard fopen

   *        semantics).  The file seek position indicator is set to point

   *        to the end of the file on exit.

   * "r+":  Open a file for update -- both reading and writing. The file must

   *        exist.  The pcap header is assumed to have been written to the

   *        file and will be read and checked.  The file seek position indicator

   *        is set to point to the first packet on exit.

   * "w+":  Create an empty file for both reading and writing.  If a file with

   *        the same name already exists, its content is erased and the file is

   *        treated as a new empty pcap file.  Since this new file will not have

   *        a pcap header, the caller is responsible for calling Init before

   *        saving any packet data.  On exit, the file seek position indicator is

   *        set to point to the beginning of the file.

   * "a+"   Open a file for reading and appending.  The file must exist and have a

   *        valid pcap header written (N.B. this is different from standard fopen

   *        semantics).  The file seek position indicator is set to point

   *        to the end of the file on exit.  Existing content is preserved.

   * \endverbatim

   * Since a pcap file is always a binary file, the file type is automatically

   * Since a pcap file is always a binary file, the file type is automatically

   * selected as a binary file.  For example, providing a mode string "a+"

   * selected as a binary file (fstream::binary is automatically ored with the mode

   * results in the underlying OS file being opened in "a+b" mode.

   * field).

   * \param filename String containing the name of the file.

   * \param filename String containing the name of the file.

   * \param mode String containing the access mode for the file.

   * \param mode the access mode for the file.

100

101

   * \returns Error indication that should be interpreted as, "did an error

102

   * happen"?  That is, the method returns false if the open succeeds, true

103

   * otherwise.  The errno variable will be set by the OS to to provide a

104

   * more descriptive failure indication.

105

*/

*/

106

  bool Open (std::string const &filename, std::string const &mode);

  void Open (std::string const &filename, std::ios::openmode mode);

107

108

/**

/**

109

   * Close the underlying file.

   * Close the underlying file.

Lines 138-144	Link Here

138

   * \warning Calling this method on an existing file will result in the loss

111

   * \warning Calling this method on an existing file will result in the loss

139

   * any existing data.

112

   * any existing data.

140

*/

113

*/

141

  bool Init (uint32_t dataLinkType,

114

  void Init (uint32_t dataLinkType,

142

             uint32_t snapLen = SNAPLEN_DEFAULT,

115

             uint32_t snapLen = SNAPLEN_DEFAULT,

143

             int32_t timeZoneCorrection = ZONE_DEFAULT,

116

             int32_t timeZoneCorrection = ZONE_DEFAULT,

144

             bool swapMode = false);

117

             bool swapMode = false);

Lines 151-159	Link Here

151

   * \param data        Data buffer

124

   * \param data        Data buffer

152

   * \param totalLen    Total packet length

125

   * \param totalLen    Total packet length

153

126

154

   * \return true on error, false otherwise

155

*/

127

*/

156

  bool Write (uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen);

128

  void Write (uint32_t tsSec, uint32_t tsUsec, uint8_t const * const data, uint32_t totalLen);

129

130

/**

131

   * \brief Write next packet to file

132

133

   * \param tsSec       Packet timestamp, seconds

134

   * \param tsUsec      Packet timestamp, microseconds

135

   * \param p           Packet to write

136

137

*/

138

  void Write (uint32_t tsSec, uint32_t tsUsec, Ptr<const Packet> p);

139

/**

140

   * \brief Write next packet to file

141

142

   * \param tsSec       Packet timestamp, seconds

143

   * \param tsUsec      Packet timestamp, microseconds

144

   * \param header      Header to write, in front of packet

145

   * \param p           Packet to write

146

147

*/

148

  void Write (uint32_t tsSec, uint32_t tsUsec, Header &header, Ptr<const Packet> p);

149

157

150

158

/**

151

/**

159

   * \brief Read next packet from file

152

   * \brief Read next packet from file

Lines 166-174	Link Here

166

   * \param origLen     [out] Original length

159

   * \param origLen     [out] Original length

167

   * \param readLen     [out] Number of bytes read

160

   * \param readLen     [out] Number of bytes read

168

161

169

   * \return true if read failed, false otherwise

170

*/

162

*/

171

  bool Read (uint8_t * const data,

163

  void Read (uint8_t * const data,

172

             uint32_t maxBytes,

164

             uint32_t maxBytes,

173

             uint32_t &tsSec,

165

             uint32_t &tsSec,

174

             uint32_t &tsUsec,

166

             uint32_t &tsUsec,

Lines 290-302	Link Here

290

  void Swap (PcapFileHeader *from, PcapFileHeader *to);

282

  void Swap (PcapFileHeader *from, PcapFileHeader *to);

291

  void Swap (PcapRecordHeader *from, PcapRecordHeader *to);

283

  void Swap (PcapRecordHeader *from, PcapRecordHeader *to);

292

284

293

  bool WriteFileHeader (void);

285

  void WriteFileHeader (void);

294

  bool ReadAndVerifyFileHeader (void);

286

  uint32_t WritePacketHeader (uint32_t tsSec, uint32_t tsUsec, uint32_t totalLen);

287

  void ReadAndVerifyFileHeader (void);

295

288

296

  std::string    m_filename;

289

  std::string    m_filename;

297

  FILE          *m_filePtr;

290

  std::fstream   m_file;

298

  PcapFileHeader m_fileHeader;

291

  PcapFileHeader m_fileHeader;

299

  bool m_haveFileHeader;

300

  bool m_swapMode;

292

  bool m_swapMode;

301

};

293

};

302

294

(-)a/src/helper/csma-helper.cc (-2 / +3 lines)

Lines 98-104	Link Here

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

100

101

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, "w", PcapHelper::DLT_EN10MB);

101

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out,

102

                                                     PcapHelper::DLT_EN10MB);

102

  if (promiscuous)

103

  if (promiscuous)

103

104

      pcapHelper.HookDefaultSink<CsmaNetDevice> (device, "PromiscSniffer", file);

105

      pcapHelper.HookDefaultSink<CsmaNetDevice> (device, "PromiscSniffer", file);

Lines 159-165	Link Here

159

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

160

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

160

161

162

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename, "w");

163

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);

163

164

//

165

//

165

      // The MacRx trace source provides our "r" event.

166

      // The MacRx trace source provides our "r" event.

(-)a/src/helper/emu-helper.cc (-2 / +2 lines)

Lines 91-97	Link Here

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, "w", PcapHelper::DLT_EN10MB);

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out, PcapHelper::DLT_EN10MB);

  if (promiscuous)

  if (promiscuous)

      pcapHelper.HookDefaultSink<EmuNetDevice> (device, "PromiscSniffer", file);

      pcapHelper.HookDefaultSink<EmuNetDevice> (device, "PromiscSniffer", file);

Lines 152-158	Link Here

152

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

152

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

153

154

155

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename, "w");

155

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);

156

157

//

157

//

158

      // The MacRx trace source provides our "r" event.

158

      // The MacRx trace source provides our "r" event.




      filename = pcapHelper.GetFilenameFromInterfacePair (prefix, ipv4, interface);
    }

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out, PcapHelper::DLT_RAW);

  //
  // However, we only hook the trace source once to avoid multiple trace sink

      filename = pcapHelper.GetFilenameFromInterfacePair (prefix, ipv6, interface);
    }

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out, PcapHelper::DLT_RAW);

  //
  // However, we only hook the trace source once to avoid multiple trace sink

          filename = asciiTraceHelper.GetFilenameFromInterfacePair (prefix, ipv4, interface);
        }

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);

      //
      // However, we only hook the trace sources once to avoid multiple trace sink

          filename = asciiTraceHelper.GetFilenameFromInterfacePair (prefix, ipv6, interface);
        }

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);

      //
      // However, we only hook the trace sources once to avoid multiple trace sink

(-)a/src/helper/point-to-point-helper.cc (-2 / +3 lines)

Lines 99-105	Link Here

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

100

101

102

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, "w", PcapHelper::DLT_PPP);

102

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out,

103

                                                     PcapHelper::DLT_PPP);

103

  pcapHelper.HookDefaultSink<PointToPointNetDevice> (device, "PromiscSniffer", file);

104

  pcapHelper.HookDefaultSink<PointToPointNetDevice> (device, "PromiscSniffer", file);

104

105

106

Lines 154-160	Link Here

154

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

155

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

155

156

157

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename, "w");

158

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);

158

159

//

160

//

160

      // The MacRx trace source provides our "r" event.

161

      // The MacRx trace source provides our "r" event.




Ptr<PcapFileWrapper>
PcapHelper::CreateFile (
  std::string filename, 
  std::ios::openmode filemode,
  uint32_t    dataLinkType, 
  uint32_t    snapLen, 
  int32_t     tzCorrection)

  NS_LOG_FUNCTION (filename << filemode << dataLinkType << snapLen << tzCorrection);

  Ptr<PcapFileWrapper> file = CreateObject<PcapFileWrapper> ();
  file->Open (filename, filemode);
  NS_ABORT_MSG_IF (file->Fail (), "Unable to Open " << filename << " for mode " << filemode);

  file->Init (dataLinkType, snapLen, tzCorrection);
  NS_ABORT_MSG_IF (file->Fail (), "Unable to Init " << filename);

  //
  // Note that the pcap helper promptly forgets all about the pcap file.  We

}

Ptr<OutputStreamWrapper>
AsciiTraceHelper::CreateFileStream (std::string filename, std::ios::openmode filemode)
{
  NS_LOG_FUNCTION (filename << filemode);

  std::ofstream *ofstream = new std::ofstream;
  std::ios_base::openmode mode = std::ios_base::out | std::ios_base::trunc;

  ofstream->open (filename.c_str (), filemode);
    {
      mode = std::ios_base::out | std::ios_base::app;
    }
  else if (filemode == "w")
    {
      mode = std::ios_base::out | std::ios_base::trunc;
    }
  else
    {
      NS_ABORT_MSG ("AsciiTraceHelper::CreateFileStream(): Unexpected file mode");
    }

  ofstream->open (filename.c_str (), mode);
  NS_ABORT_MSG_UNLESS (ofstream->is_open (), "AsciiTraceHelper::CreateFileStream():  Unable to Open " << 
                       filename << " for mode " << filemode);
  

(-)a/src/helper/trace-helper.h (-2 / +3 lines)

Lines 84-90	Link Here

/**

/**

   * @brief Create and initialize a pcap file.

   * @brief Create and initialize a pcap file.

*/

*/

  Ptr<PcapFileWrapper> CreateFile (std::string filename, std::string filemode,

  Ptr<PcapFileWrapper> CreateFile (std::string filename, std::ios::openmode filemode,

                                  uint32_t dataLinkType,  uint32_t snapLen = 65535, int32_t tzCorrection = 0);

                                  uint32_t dataLinkType,  uint32_t snapLen = 65535, int32_t tzCorrection = 0);

/**

/**

   * @brief Hook a trace source to the default trace sink

   * @brief Hook a trace source to the default trace sink

Lines 156-162	Link Here

156

   * that can solve the problem so we use one of those to carry the stream

156

   * that can solve the problem so we use one of those to carry the stream

157

   * around and deal with the lifetime issues.

157

   * around and deal with the lifetime issues.

158

*/

158

*/

159

  Ptr<OutputStreamWrapper> CreateFileStream (std::string filename, std::string filemode = "w");

159

  Ptr<OutputStreamWrapper> CreateFileStream (std::string filename,

160

                                             std::ios::openmode filemode = std::ios::out);

160

161

/**

162

/**

162

   * @brief Hook a trace source to the default enqueue operation trace sink that

163

   * @brief Hook a trace source to the default enqueue operation trace sink that

(-)a/src/helper/wimax-helper.cc (-2 / +2 lines)

Lines 480-486	Link Here

480

481

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

481

          filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);

482

483

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename, "w");

483

      Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);

484

485

      uint32_t nodeid = nd->GetNode ()->GetId ();

485

      uint32_t nodeid = nd->GetNode ()->GetId ();

486

      uint32_t deviceid = nd->GetIfIndex ();

486

      uint32_t deviceid = nd->GetIfIndex ();

Lines 586-592	Link Here

586

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

586

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

587

588

589

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, "w", PcapHelper::DLT_EN10MB);

589

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out, PcapHelper::DLT_EN10MB);

590

591

  phy->TraceConnectWithoutContext ("Tx", MakeBoundCallback (&PcapSniffTxEvent, file));

591

  phy->TraceConnectWithoutContext ("Tx", MakeBoundCallback (&PcapSniffTxEvent, file));

592

  phy->TraceConnectWithoutContext ("Rx", MakeBoundCallback (&PcapSniffRxEvent, file));

592

  phy->TraceConnectWithoutContext ("Rx", MakeBoundCallback (&PcapSniffRxEvent, file));

(-)a/src/helper/yans-wifi-helper.cc (-1 / +1 lines)

Lines 409-415	Link Here

409

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

409

      filename = pcapHelper.GetFilenameFromDevice (prefix, device);

410

411

412

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, "w", m_pcapDlt);

412

  Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out, m_pcapDlt);

413

414

  phy->TraceConnectWithoutContext ("PromiscSnifferTx", MakeBoundCallback (&PcapSniffTxEvent, file));

414

  phy->TraceConnectWithoutContext ("PromiscSnifferTx", MakeBoundCallback (&PcapSniffTxEvent, file));

415

  phy->TraceConnectWithoutContext ("PromiscSnifferRx", MakeBoundCallback (&PcapSniffRxEvent, file));

415

  phy->TraceConnectWithoutContext ("PromiscSnifferRx", MakeBoundCallback (&PcapSniffRxEvent, file));

Return to bug 872