00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include <fstream>
00027
00028 #include "ns3/log.h"
00029 #include "ns3/assert.h"
00030 #include "ns3/abort.h"
00031 #include "ns3/simulator.h"
00032 #include "pcap-writer.h"
00033 #include "packet.h"
00034
00035 NS_LOG_COMPONENT_DEFINE ("PcapWriter");
00036
00037 namespace ns3 {
00038
00039 enum {
00040 PCAP_ETHERNET = 1,
00041 PCAP_PPP = 9,
00042 PCAP_RAW_IP = 101,
00043 PCAP_80211 = 105,
00044 };
00045
00046 PcapWriter::PcapWriter ()
00047 {
00048 NS_LOG_FUNCTION (this);
00049 NS_LOG_LOGIC ("m_writer = 0");
00050 m_writer = 0;
00051 }
00052
00053 PcapWriter::~PcapWriter ()
00054 {
00055 NS_LOG_FUNCTION (this);
00056
00057 if (m_writer != 0)
00058 {
00059 NS_LOG_LOGIC ("m_writer nonzero " << m_writer);
00060 if (m_writer->is_open ())
00061 {
00062 NS_LOG_LOGIC ("m_writer open. Closing " << m_writer);
00063 m_writer->close ();
00064 }
00065
00066 NS_LOG_LOGIC ("Deleting writer " << m_writer);
00067 delete m_writer;
00068
00069 NS_LOG_LOGIC ("m_writer = 0");
00070 m_writer = 0;
00071 }
00072 else
00073 {
00074 NS_LOG_LOGIC ("m_writer == 0");
00075 }
00076 }
00077
00078 void
00079 PcapWriter::Open (std::string const &name)
00080 {
00081 NS_LOG_FUNCTION (this << name);
00082 NS_ABORT_MSG_UNLESS (m_writer == 0, "PcapWriter::Open(): m_writer already allocated (std::ofstream leak detected)");
00083
00084 m_writer = new std::ofstream ();
00085 NS_ABORT_MSG_UNLESS (m_writer, "PcapWriter::Open(): Cannot allocate m_writer");
00086
00087 NS_LOG_LOGIC ("Created writer " << m_writer);
00088
00089 m_writer->open (name.c_str ());
00090 NS_ABORT_MSG_IF (m_writer->fail (), "PcapWriter::Open(): m_writer->open(" << name.c_str () << ") failed");
00091
00092 NS_ASSERT_MSG (m_writer->is_open (), "PcapWriter::Open(): m_writer not open");
00093
00094 NS_LOG_LOGIC ("Writer opened successfully");
00095 }
00096
00097 void
00098 PcapWriter::WriteEthernetHeader (void)
00099 {
00100 NS_LOG_FUNCTION_NOARGS ();
00101 WriteHeader (PCAP_ETHERNET);
00102 }
00103
00104 void
00105 PcapWriter::WriteIpHeader (void)
00106 {
00107 NS_LOG_FUNCTION_NOARGS ();
00108 WriteHeader (PCAP_RAW_IP);
00109 }
00110
00111 void
00112 PcapWriter::WriteWifiHeader (void)
00113 {
00114 NS_LOG_FUNCTION_NOARGS ();
00115 WriteHeader (PCAP_80211);
00116 }
00117
00118 void
00119 PcapWriter::WritePppHeader (void)
00120 {
00121 NS_LOG_FUNCTION_NOARGS ();
00122 WriteHeader (PCAP_PPP);
00123 }
00124
00125 void
00126 PcapWriter::WriteHeader (uint32_t network)
00127 {
00128 NS_LOG_FUNCTION (this << network);
00129 Write32 (0xa1b2c3d4);
00130 Write16 (2);
00131 Write16 (4);
00132 Write32 (0);
00133 Write32 (0);
00134 Write32 (0xffff);
00135 Write32 (network);
00136 }
00137
00138 void
00139 PcapWriter::WritePacket (Ptr<const Packet> packet)
00140 {
00141 if (m_writer != 0)
00142 {
00143 uint64_t current = Simulator::Now ().GetMicroSeconds ();
00144 uint64_t s = current / 1000000;
00145 uint64_t us = current % 1000000;
00146 Write32 (s & 0xffffffff);
00147 Write32 (us & 0xffffffff);
00148 Write32 (packet->GetSize ());
00149 Write32 (packet->GetSize ());
00150 WriteData (packet->PeekData (), packet->GetSize ());
00151 }
00152 }
00153
00154 void
00155 PcapWriter::WriteData (uint8_t const*buffer, uint32_t size)
00156 {
00157 m_writer->write ((char const *)buffer, size);
00158 }
00159
00160 void
00161 PcapWriter::Write32 (uint32_t data)
00162 {
00163 uint8_t buffer[4];
00164 buffer[0] = (data >> 0) & 0xff;
00165 buffer[1] = (data >> 8) & 0xff;
00166 buffer[2] = (data >> 16) & 0xff;
00167 buffer[3] = (data >> 24) & 0xff;
00168 WriteData (buffer, 4);
00169 }
00170
00171 void
00172 PcapWriter::Write16 (uint16_t data)
00173 {
00174 uint8_t buffer[2];
00175 buffer[0] = (data >> 0) & 0xff;
00176 buffer[1] = (data >> 8) & 0xff;
00177 WriteData (buffer, 2);
00178 }
00179
00180 }