Attachment #393 for bug #443

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

(-)a/examples/wifi-wired-bridging.cc (-2 / +5 lines)

Lines 183-190 int main (int argc, char *argv[])	Link Here

183

  apps.Start (Seconds (0.5));

183

  apps.Start (Seconds (0.5));

184

  apps.Stop (Seconds (3.0));

184

  apps.Stop (Seconds (3.0));

185

186

  YansWifiPhyHelper::EnablePcap ("wifi-wired-bridging", staNodes[1].Get (1));

186

  WifiHelper::EnablePcap ("wifi-wired-bridging", staNodes[1].Get (1));

187

  YansWifiPhyHelper::EnablePcap ("wifi-wired-bridging", staNodes[0].Get (0));

187

  WifiHelper::EnablePcap ("wifi-wired-bridging", staNodes[0].Get (0));

188

189

  YansWifiPhyHelper::EnablePcap ("wifi-wired-bridging-promisc", staNodes[1].Get (1));

190

  YansWifiPhyHelper::EnablePcap ("wifi-wired-bridging-promisc", staNodes[0].Get (0));

188

  std::ofstream os;

191

  std::ofstream os;

189

  os.open ("wifi-wired-bridging.mob");

192

  os.open ("wifi-wired-bridging.mob");

190

  MobilityHelper::EnableAsciiAll (os);

193

  MobilityHelper::EnableAsciiAll (os);




                   PointerValue (),
                   MakePointerAccessor (&CsmaNetDevice::m_receiveErrorModel),
                   MakePointerChecker<ErrorModel> ())

    //
    // Transmit queueing discipline for the device which includes its own set
    // of trace hooks.
    //
    .AddAttribute ("TxQueue", 
                   "A queue to use as the transmit queue in the device.",
                   PointerValue (),
                   MakePointerAccessor (&CsmaNetDevice::m_queue),
                   MakePointerChecker<Queue> ())

    //
    // Trace sources at the "top" of the net device, where packets transition
    // to/from higher layers.
    //
    .AddTraceSource ("MacTx", 
                     "Trace source indicating a packet has arrived for transmission by this device",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_macTxTrace))
    .AddTraceSource ("MacTxDrop", 
                     "Trace source indicating a packet has been dropped by the device before transmission",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_macTxDropTrace))
    .AddTraceSource ("MacRx", 
                     "Trace source indicating a packet has been received by this device and is being forwarded up the stack",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_macRxTrace))
    //
    // Trace souces at the "bottom" of the net device, where packets transition
    // to/from the channel.
    //
    .AddTraceSource ("PhyTxStart", 
                     "Trace source indicating a packet has begun transmitting over the channel",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_phyTxStartTrace))
    .AddTraceSource ("PhyTx", 
                     "Trace source indicating a packet has been completely transmitted over the channel",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_phyTxTrace))
    .AddTraceSource ("PhyTxDrop", 
                     "Trace source indicating a packet has been dropped by the device during transmission",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_phyTxDropTrace))
    .AddTraceSource ("PhyRxStart", 
                     "Trace source indicating a packet has begun being received by the device",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_phyRxStartTrace))
    .AddTraceSource ("PhyRx", 
                     "Trace source indicating a packet has been completely received by the device",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_phyRxTrace))
    .AddTraceSource ("PhyRxDrop", 
                     "Trace source indicating a packet has been dropped by the device during reception",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_phyRxDropTrace))
    .AddTraceSource ("PhyTxBackoff", 
                     "Trace source indicating a packet has been delayed by the CSMA backoff process",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_phyTxBackoffTrace))

    //
    // Trace sources designed to simulate a packet sniffer facility (tcpdump). 
    //
    .AddTraceSource ("Sniffer", 
                     "Trace source simulating a non-promiscuous packet sniffer attached to the device",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_snifferTrace))
    .AddTraceSource ("PromiscSniffer", 
                     "Trace source simulating a promiscuous packet sniffer attached to the device",
                     MakeTraceSourceAccessor (&CsmaNetDevice::m_promiscSnifferTrace))
    ;
  return tid;
}

  m_channel = 0; 

  // 
  // We would like to let the attribute system take care of initializing the 
  // packet encapsulation stuff, but we also don't want to get caught up in
  // initialization order changes.  So we'll get the three problem variables
  // into a consistent state here before the attribute calls, and then depend
  // on the semantics of the setters to preserve a consistent state.  This 
  // really doesn't have to be the same set of values as the initial values 
  // set by the attributes, but it does have to be a consistent set.  That is,
  // you can just change the default encapsulation mode above without having 
  // to change it here.
  //
  m_encapMode = DIX;
  m_frameSize = DEFAULT_FRAME_SIZE;

    case DIX:
      NS_LOG_LOGIC ("Encapsulating packet as DIX (type interpretation)");
      //
      // This corresponds to the type interpretation of the lengthType field as
      // in the old Ethernet Blue Book.
      //
      lengthType = protocolNumber;
      break;

}

  void
CsmaNetDevice::TransmitStart (void)
{
  NS_LOG_FUNCTION_NOARGS ();

  //
  // This function is called to start the process of transmitting a packet.  We 
  // expect that the packet to transmit will be found in m_currentPkt.
  //
  NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::TransmitStart(): m_currentPkt not set");

  NS_LOG_LOGIC ("m_currentPkt = " << m_currentPkt);
  NS_LOG_LOGIC ("UID = " << m_currentPkt->GetUid ());

  //
  // Only transmit if the send side of net device is enabled
  //
  if (IsSendEnabled () == false)
    {
      m_phyTxDropTrace (m_currentPkt);
      m_currentPkt = 0;
      return;
    }

  //
  // Somebody has called here telling us to start transmitting a packet.  They 
  // can only do this if the state machine is in the READY or BACKOFF state.
  // Specifically, if we are ready to start transmitting, we cannot already
  // be transmitting (i.e., BUSY)
  //
  NS_ASSERT_MSG ((m_txMachineState == READY) || (m_txMachineState == BACKOFF), 
                 "Must be READY to transmit. Tx state is: " << m_txMachineState);

  //
  // Now we have to sense the state of the medium and either start transmitting
  // if it is idle, or backoff our transmission if someone else is on the wire.
  //
  if (IsSendEnabled () == false)
    {
      return;
    }

  if (m_channel->GetState () != IDLE)
    {
      //
      // The channel is busy -- backoff and rechedule TransmitStart() unless
      // we have exhausted all of our retries.
      //
      m_txMachineState = BACKOFF;


        } 
      else 
        {
          m_phyTxBackoffTrace (m_currentPkt);

          m_backoff.IncrNumRetries ();
          Time backoffTime = m_backoff.GetBackoffTime ();


      //
      // The channel is free, transmit the packet
      //
      m_txMachineState = BUSY;
      Time tEvent = Seconds (m_bps.CalculateTxTime (m_currentPkt->GetSize ()));
      
      NS_LOG_LOGIC ("Schedule TransmitCompleteEvent in " << tEvent.GetSeconds () << "sec");
      
      Simulator::Schedule (tEvent, &CsmaNetDevice::TransmitCompleteEvent, this);

      if (m_channel->TransmitStart (m_currentPkt, m_deviceId) == false)
        {
          NS_LOG_WARN ("Channel TransmitStart returns an error");
          m_phyTxDropTrace (m_currentPkt);
          m_currentPkt = 0;
          m_txMachineState = READY;
        } 
      else 
        {
          //
          // Transmission succeeded, reset the backoff time parameters and
          // schedule a transmit complete event.
          //
          m_backoff.ResetBackoffTime ();
          m_txMachineState = BUSY;
          m_phyTxStartTrace (m_currentPkt);

          Time tEvent = Seconds (m_bps.CalculateTxTime (m_currentPkt->GetSize ()));
          NS_LOG_LOGIC ("Schedule TransmitCompleteEvent in " << tEvent.GetSeconds () << "sec");
          Simulator::Schedule (tEvent, &CsmaNetDevice::TransmitCompleteEvent, this);
        }
    }
}


  void
CsmaNetDevice::TransmitAbort (void)

  NS_LOG_FUNCTION_NOARGS ();

  //
  // When we started the process of transmitting the current packet, it was 
  // placed in m_currentPkt.  So we had better find one there.
  //
  NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::TransmitAbort(): m_currentPkt zero");
  NS_LOG_LOGIC ("m_currentPkt=" << m_currentPkt);
  NS_LOG_LOGIC ("Pkt UID is " << m_currentPkt->GetUid () << ")");

  m_phyTxDropTrace (m_currentPkt);
  m_currentPkt = 0;

  NS_ASSERT_MSG (m_txMachineState == BACKOFF, "Must be in BACKOFF state to abort.  Tx state is: " << m_txMachineState);
  //
  m_dropTrace (m_currentPkt);

  // 
  // We're done with that one, so reset the backoff algorithm and ready the

    {
      m_currentPkt = m_queue->Dequeue ();
      NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::TransmitAbort(): IsEmpty false but no Packet on queue?");
      m_snifferTrace (m_currentPkt);
      m_promiscSnifferTrace (m_currentPkt);
      TransmitStart ();
    }
}

  NS_LOG_LOGIC ("Pkt UID is " << m_currentPkt->GetUid () << ")");

  m_channel->TransmitEnd (); 
  m_phyTxTrace (m_currentPkt);
  m_currentPkt = 0;

  NS_LOG_LOGIC ("Schedule TransmitReadyEvent in " << m_tInterframeGap.GetSeconds () << "sec");


  m_txMachineState = READY;

  //
  // We expect that the packet we had been transmitting was cleared when the 
  // TransmitCompleteEvent() was executed.
  //
  NS_ASSERT_MSG (m_currentPkt == 0, "CsmaNetDevice::TransmitReadyEvent(): m_currentPkt nonzero");
  NS_LOG_LOGIC ("m_currentPkt=" << m_currentPkt);
  NS_LOG_LOGIC ("Pkt UID is " << m_currentPkt->GetUid () << ")");

  //
  // Get the next packet from the queue for transmitting

    {
      m_currentPkt = m_queue->Dequeue ();
      NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::TransmitReadyEvent(): IsEmpty false but no Packet on queue?");
      m_snifferTrace (m_currentPkt);
      m_promiscSnifferTrace (m_currentPkt);
      TransmitStart ();
    }
}

  multicast6Node.CopyFrom(mac);

  //
  // We never forward up packets that we sent.  Real devices don't do this since
  // their receivers are disabled during send, so we don't.
  // silently (no tracing) since it would really never get here in a real device.
  // 
  if (senderDevice == this)
    {
      return;
    }

  //
  // Hit the trace hook.  This trace will fire on all packets received from the
  // channel except those originated by this device.
  //
  m_phyRxTrace (packet);

  // 
  // Only receive if the send side of net device is enabled
  //
  if (IsReceiveEnabled () == false)
    {
      m_phyRxDropTrace (packet);
      return;
    }


  if (m_receiveErrorModel && m_receiveErrorModel->IsCorrupt (packet) )
    {
      NS_LOG_LOGIC ("Dropping pkt due to error model ");
      m_phyRxDropTrace (packet);
    }
  else
    {

          protocol = header.GetLengthType ();
        }

      //
      // Classify the packet based on its destination.
      //
      PacketType packetType;
      
      if (header.GetDestination ().IsBroadcast ())
        {
          packetType = PACKET_BROADCAST;
          m_rxTrace (originalPacket);
        }
      else if (header.GetDestination ().IsMulticast () ||
          header.GetDestination() == multicast6Node ||

          header.GetDestination() == multicast6AllHosts)
        {
          packetType = PACKET_MULTICAST;          
          m_rxTrace (originalPacket);
        }
      else if (header.GetDestination () == m_address)
        {
          packetType = PACKET_HOST;
          m_rxTrace (originalPacket);
        }
      else
        {
          packetType = PACKET_OTHERHOST;
        }

      // 
      // For all kinds of packetType we receive, we hit the promiscuous sniffer
      // hook and pass a copy up to the promiscuous callback.  Pass a copy to 
      // make sure that nobody messes with our packet.
      //
      m_promiscSnifferTrace (originalPacket);
      if (!m_promiscRxCallback.IsNull ())
        {
          m_promiscRxCallback (this, packet->Copy (), protocol, header.GetSource (), header.GetDestination (), packetType);
        }

      //
      // If this packet is not destined for some other host, it must be for us
      // as either a broadcast, multicast or unicast.  We need to hit the mac
      // packet received trace hook and forward the packet up the stack.
      //
      if (packetType != PACKET_OTHERHOST)
        {
          m_snifferTrace (originalPacket);
          m_macRxTrace (originalPacket);
          m_rxCallback (this, packet, protocol, header.GetSource ());
        }
    }

CsmaNetDevice::SendFrom (Ptr<Packet> packet, const Address& src, const Address& dest, uint16_t protocolNumber)
{
  NS_LOG_FUNCTION (packet << src << dest << protocolNumber);
  NS_LOG_LOGIC ("packet =" << packet);
  NS_LOG_LOGIC ("UID is " << packet->GetUid () << ")");

  NS_ASSERT (IsLinkUp ());

  //
  if (IsSendEnabled () == false)
    {
      m_macTxDropTrace (packet);
      return false;
    }


  Mac48Address source = Mac48Address::ConvertFrom (src);
  AddHeader (packet, source, destination, protocolNumber);

  m_macTxTrace (packet);

  //
  // Place the packet to be sent on the send queue.  Note that the 
  // queue may fire a drop trace, but we will too.
  //
  if (m_queue->Enqueue(packet) == false)
    {
      m_macTxDropTrace (packet);
      return false;
    }


  //
  if (m_txMachineState == READY) 
    {
      if (m_queue->IsEmpty () == false)
      // The next packet to be transmitted goes in m_currentPkt
      //
      m_currentPkt = m_queue->Dequeue ();
      if (m_currentPkt != 0)
        {
          m_currentPkt = m_queue->Dequeue ();
          NS_ASSERT_MSG (m_currentPkt != 0, "CsmaNetDevice::SendFrom(): IsEmpty false but no Packet on queue?");
          m_promiscSnifferTrace (packet);
          m_snifferTrace (packet);
          TransmitStart ();
        }
    }




  Ptr<Queue> m_queue;

  /**
   * Error model for receive packet events.  When active this model will be
   * used to model transmission errors by marking some of the packets 
   * received as corrupt.
   */
  Ptr<ErrorModel> m_receiveErrorModel;

  /**
   * The trace source fired when packets come into the "top" of the device
   * at the L3/L2 transition, before being queued for transmission.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macTxTrace;

  /**
   * The trace source fired when packets coming into the "top" of the device
   * at the L3/L2 transition are dropped before being queued for transmission.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macTxDropTrace;

  /**
   * The trace source fired for packets successfully received by the device
   * immediately before being forwarded up to higher layers (at the L2/L3 
   * transition).
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macRxTrace;

  /**
   * The trace source fired when a packet starts the transmission process on
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxStartTrace;

  /**
   * The trace source fired when a packet ends the transmission process on
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxTrace;

  /**
   * The trace source fired when the phy layer drops a packet as it tries
   * to transmit it.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxDropTrace;

  /**
   * The trace source fired when a packet ends the reception process from
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxTrace;

  /**
   * The trace source fired when a packet ends the reception process from
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxStartTrace;

  /**
   * The trace source fired when the phy layer drops a packet it has received.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxDropTrace;

  /**
   * The trace source fired when the phy layer is forced to begin the backoff
   * process for a packet.  This can happen a number of times as the backoff
   * sequence is repeated with increasing delays.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxBackoffTrace;

  /**
   * A trace source that emulates a non-promiscuous protocol sniffer connected 
   * to the device.  Unlike your average everyday sniffer, this trace source 
   * will not fire on PACKET_OTHERHOST events.
   *
   * On the transmit size, this trace hook will fire after a packet is dequeued
   * from the device queue for transmission.  In Linux, for example, this would
   * correspond to the point just before a device hard_start_xmit where 
   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET 
   * ETH_P_ALL handlers.
   *
   * On the receive side, this trace hook will fire when a packet is received,
   * just before the receive callback is executed.  In Linux, for example, 
   * this would correspond to the point at which the packet is dispatched to 
   * packet sniffers in netif_receive_skb.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_snifferTrace;

  /**
   * A trace source that emulates a promiscuous mode protocol sniffer connected
   * to the device.  This trace source fire on packets destined for any host
   * just like your average everyday packet sniffer.
   *
   * On the transmit size, this trace hook will fire after a packet is dequeued
   * from the device queue for transmission.  In Linux, for example, this would
   * correspond to the point just before a device hard_start_xmit where 
   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET 
   * ETH_P_ALL handlers.
   *
   * On the receive side, this trace hook will fire when a packet is received,
   * just before the receive callback is executed.  In Linux, for example, 
   * this would correspond to the point at which the packet is dispatched to 
   * packet sniffers in netif_receive_skb.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_promiscSnifferTrace;

  /**
   * The Node to which this device is attached.

   * The callback used to notify higher layers that a packet has been received.
   */
  NetDevice::ReceiveCallback m_rxCallback;

  /**
   * The callback used to notify higher layers that a packet has been received in promiscuous mode.
   */

(-)a/src/devices/emu/emu-net-device.cc (-51 / +149 lines)

Lines 22-38	Link Here

#include "ns3/log.h"

#include "ns3/log.h"

#include "ns3/queue.h"

#include "ns3/queue.h"

#include "ns3/simulator.h"

#include "ns3/simulator.h"

#include "ns3/realtime-simulator-impl.h"

#include "ns3/mac48-address.h"

#include "ns3/ethernet-header.h"

#include "ns3/ethernet-header.h"

#include "ns3/ethernet-trailer.h"

#include "ns3/ethernet-trailer.h"

#include "ns3/llc-snap-header.h"

#include "ns3/llc-snap-header.h"

#include "ns3/boolean.h"

#include "ns3/uinteger.h"

#include "ns3/pointer.h"

#include "ns3/string.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/trace-source-accessor.h"

#include "ns3/pointer.h"

#include "ns3/channel.h"

#include "ns3/channel.h"

#include "ns3/system-thread.h"

#include "ns3/system-thread.h"

#include "ns3/string.h"

#include "ns3/realtime-simulator-impl.h"

#include "ns3/boolean.h"

#include "ns3/mac48-address.h"

#include <sys/wait.h>

#include <sys/wait.h>

#include <sys/stat.h>

#include <sys/stat.h>

Lines 82-95 EmuNetDevice::GetTypeId (void)	Link Here

                   TimeValue (Seconds (0.)),

                   TimeValue (Seconds (0.)),

                   MakeTimeAccessor (&EmuNetDevice::m_tStop),

                   MakeTimeAccessor (&EmuNetDevice::m_tStop),

                   MakeTimeChecker ())

                   MakeTimeChecker ())

//

    // Transmit queueing discipline for the device which includes its own set

    // of trace hooks.  Note that this is really going to run "on top of" the

    // queueing discipline that will most likely be present in the devices of

    // the underlying operating system.

//

    .AddAttribute ("TxQueue",

    .AddAttribute ("TxQueue",

                   "A queue to use as the transmit queue in the device.",

                   "A queue to use as the transmit queue in the device.",

                   PointerValue (),

                   PointerValue (),

                   MakePointerAccessor (&EmuNetDevice::m_queue),

                   MakePointerAccessor (&EmuNetDevice::m_queue),

                   MakePointerChecker<Queue> ())

                   MakePointerChecker<Queue> ())

    .AddTraceSource ("Rx",

                     "Trace source indicating recvfrom of packet destined for broadcast, multicast or local address.",

//

                     MakeTraceSourceAccessor (&EmuNetDevice::m_rxTrace))

100

    // Trace sources at the "top" of the net device, where packets transition

101

    // to/from higher layers.  These points do not really correspond to the

102

    // MAC layer of the underlying operating system, but exist to provide

103

    // a consitent tracing environment.  These trace hooks should really be

104

    // interpreted as the points at which a packet leaves the ns-3 environment

105

    // destined for the underlying operating system or vice-versa.

106

//

107

    .AddTraceSource ("MacTx",

108

                     "Trace source indicating a packet has arrived for transmission by this device",

109

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macTxTrace))

110

    .AddTraceSource ("MacTxDrop",

111

                     "Trace source indicating a packet has been dropped by the device before transmission",

112

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macTxDropTrace))

113

    .AddTraceSource ("MacRx",

114

                     "Trace source indicating a packet has been received by this device and is being forwarded up the stack",

115

                     MakeTraceSourceAccessor (&EmuNetDevice::m_macRxTrace))

116

//

117

    // In normal ns-3 net devices, these trace souces correspond to the "bottom"

118

    // of the net device, where packets transition to/from the channel.  In

119

    // the case of the emu device, there is no physical layer access and so

120

    // these are duplicates of the MAC-level hooks.  Intepret these points

121

    // also as the points at which a packet leaves the ns-3 environment

122

    // destined for the underlying operating system or vice-versa.

123

//

124

    .AddTraceSource ("PhyTxStart",

125

                     "Trace source indicating a packet has begun transmitting over the channel",

126

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyTxStartTrace))

127

    .AddTraceSource ("PhyTx",

128

                     "Trace source indicating a packet has been completely transmitted over the channel",

129

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyTxTrace))

130

    .AddTraceSource ("PhyTxDrop",

131

                     "Trace source indicating a packet has been dropped by the device during transmission",

132

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyTxDropTrace))

133

    .AddTraceSource ("PhyRxStart",

134

                     "Trace source indicating a packet has begun being received by the device",

135

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyRxStartTrace))

136

    .AddTraceSource ("PhyRx",

137

                     "Trace source indicating a packet has been completely received by the device",

138

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyRxTrace))

139

    .AddTraceSource ("PhyRxDrop",

140

                     "Trace source indicating a packet has been dropped by the device during reception",

141

                     MakeTraceSourceAccessor (&EmuNetDevice::m_phyRxDropTrace))

142

143

//

144

    // Trace sources designed to simulate a packet sniffer facility (tcpdump).

145

//

146

    .AddTraceSource ("Sniffer",

147

                     "Trace source simulating a non-promiscuous packet sniffer attached to the device",

148

                     MakeTraceSourceAccessor (&EmuNetDevice::m_snifferTrace))

149

    .AddTraceSource ("PromiscSniffer",

150

                     "Trace source simulating a promiscuous packet sniffer attached to the device",

151

                     MakeTraceSourceAccessor (&EmuNetDevice::m_promiscSnifferTrace))

152

  return tid;

153

  return tid;

154

Lines 490-495 EmuNetDevice::ForwardUp (uint8_t *buf, u	Link Here

490

549

491

  NS_LOG_FUNCTION (buf << len);

550

  NS_LOG_FUNCTION (buf << len);

492

551

552

  /* IPv6 support*/

553

  uint8_t mac[6];

554

  Mac48Address multicast6AllNodes("33:33:00:00:00:01");

555

  Mac48Address multicast6AllRouters("33:33:00:00:00:02");

556

  Mac48Address multicast6AllHosts("33:33:00:00:00:03");

557

  Mac48Address multicast6Node; /* multicast address addressed to our MAC address */

558

559

  /* generate IPv6 multicast ethernet destination that nodes will accept */

560

  GetAddress().CopyTo(mac);

561

  mac[0]=0x33;

562

  mac[1]=0x33;

563

  multicast6Node.CopyFrom(mac);

564

493

//

565

//

494

  // Create a packet out of the buffer we received and free that buffer.

566

  // Create a packet out of the buffer we received and free that buffer.

495

//

567

//

Lines 504-509 EmuNetDevice::ForwardUp (uint8_t *buf, u	Link Here

504

  Ptr<Packet> originalPacket = packet->Copy ();

576

  Ptr<Packet> originalPacket = packet->Copy ();

505

577

506

//

578

//

579

  // Hit the trace hook.  This trace will fire on all packets received from the

580

  // OS (promiscuous).  Packets are received instantaneously.

581

//

582

  m_phyRxStartTrace (packet);

583

  m_phyRxTrace (packet);

584

585

//

507

  // Checksum the packet

586

  // Checksum the packet

508

//

587

//

509

  EthernetTrailer trailer;

588

  EthernetTrailer trailer;

Lines 516-558 EmuNetDevice::ForwardUp (uint8_t *buf, u	Link Here

516

  NS_LOG_LOGIC ("Pkt source is " << header.GetSource ());

595

  NS_LOG_LOGIC ("Pkt source is " << header.GetSource ());

517

  NS_LOG_LOGIC ("Pkt destination is " << header.GetDestination ());

596

  NS_LOG_LOGIC ("Pkt destination is " << header.GetDestination ());

518

597

519

  LlcSnapHeader llc;

598

  uint16_t protocol;

520

  packet->RemoveHeader (llc);

599

521

  uint16_t protocol = llc.GetType ();

600

//

601

  // If the length/type is less than 1500, it corresponds to a length

602

  // interpretation packet.  In this case, it is an 802.3 packet and

603

  // will also have an 802.2 LLC header.  If greater than 1500, we

604

  // find the protocol number (Ethernet type) directly.

605

//

606

  if (header.GetLengthType () <= 1500)

607

608

      LlcSnapHeader llc;

609

      packet->RemoveHeader (llc);

610

      protocol = llc.GetType ();

611

612

  else

613

614

      protocol = header.GetLengthType ();

615

522

616

523

  PacketType packetType;

617

  PacketType packetType;

524

618

525

  if (header.GetDestination ().IsBroadcast ())

619

  if (header.GetDestination ().IsBroadcast ())

526

620

527

      NS_LOG_LOGIC ("Pkt destination is PACKET_BROADCAST");

528

      packetType = NS3_PACKET_BROADCAST;

621

      packetType = NS3_PACKET_BROADCAST;

529

622

530

  else if (header.GetDestination ().IsMulticast ())

623

  else if (header.GetDestination ().IsMulticast () ||

624

           header.GetDestination() == multicast6Node ||

625

           header.GetDestination() == multicast6AllNodes ||

626

           header.GetDestination() == multicast6AllRouters ||

627

           header.GetDestination() == multicast6AllHosts)

531

628

532

      NS_LOG_LOGIC ("Pkt destination is PACKET_MULTICAST");

629

      packetType = NS3_PACKET_MULTICAST;

533

      packetType = NS3_PACKET_MULTICAST;

534

630

535

  else if (header.GetDestination () == m_address)

631

  else if (header.GetDestination () == m_address)

536

632

537

      NS_LOG_LOGIC ("Pkt destination is PACKET_HOST");

538

      packetType = NS3_PACKET_HOST;

633

      packetType = NS3_PACKET_HOST;

539

634

540

  else

635

  else

541

636

542

      NS_LOG_LOGIC ("Pkt destination is PACKET_OTHERHOST");

543

      packetType = NS3_PACKET_OTHERHOST;

637

      packetType = NS3_PACKET_OTHERHOST;

544

638

545

639

640

//

641

  // For all kinds of packetType we receive, we hit the promiscuous sniffer

642

  // hook and pass a copy up to the promiscuous callback.  Pass a copy to

643

  // make sure that nobody messes with our packet.

644

//

645

  m_promiscSnifferTrace (originalPacket);

546

  if (!m_promiscRxCallback.IsNull ())

646

  if (!m_promiscRxCallback.IsNull ())

547

647

548

      NS_LOG_LOGIC ("calling m_promiscRxCallback");

549

      m_promiscRxCallback (this, packet->Copy (), protocol, header.GetSource (), header.GetDestination (), packetType);

648

      m_promiscRxCallback (this, packet->Copy (), protocol, header.GetSource (), header.GetDestination (), packetType);

550

649

551

650

651

//

652

  // If this packet is not destined for some other host, it must be for us

653

  // as either a broadcast, multicast or unicast.  We need to hit the mac

654

  // packet received trace hook and forward the packet up the stack.

655

//

552

  if (packetType != NS3_PACKET_OTHERHOST)

656

  if (packetType != NS3_PACKET_OTHERHOST)

553

657

554

      m_rxTrace (originalPacket);

658

      m_snifferTrace (originalPacket);

555

      NS_LOG_LOGIC ("calling m_rxCallback");

659

      m_macRxTrace (originalPacket);

556

      m_rxCallback (this, packet, protocol, header.GetSource ());

660

      m_rxCallback (this, packet, protocol, header.GetSource ());

557

661

558

662

Lines 632-641 EmuNetDevice::SendFrom (Ptr<Packet> pack	Link Here

632

EmuNetDevice::SendFrom (Ptr<Packet> packet, const Address &src, const Address &dest, uint16_t protocolNumber)

736

EmuNetDevice::SendFrom (Ptr<Packet> packet, const Address &src, const Address &dest, uint16_t protocolNumber)

633

737

634

  NS_LOG_FUNCTION (packet << src << dest << protocolNumber);

738

  NS_LOG_FUNCTION (packet << src << dest << protocolNumber);

739

  NS_LOG_LOGIC ("packet =" << packet);

740

  NS_LOG_LOGIC ("UID is " << packet->GetUid () << ")");

635

741

636

  if (IsLinkUp () == false)

742

  if (IsLinkUp () == false)

637

743

638

      NS_LOG_LOGIC ("Link is down, returning");

744

      m_macTxDropTrace (packet);

639

      return false;

745

      return false;

640

746

641

747

Lines 646-679 EmuNetDevice::SendFrom (Ptr<Packet> pack	Link Here

646

  NS_LOG_LOGIC ("Transmit packet from " << source);

752

  NS_LOG_LOGIC ("Transmit packet from " << source);

647

  NS_LOG_LOGIC ("Transmit packet to " << destination);

753

  NS_LOG_LOGIC ("Transmit packet to " << destination);

648

754

649

#if 0

755

//

650

756

  // We've got to pick either DIX (Ethernet) or LLC/SNAP (IEEE 802.3) as a

651

    struct ifreq ifr;

757

  // packet format.  IEEE 802.3 is slightly more formally correct, so we

652

    bzero (&ifr, sizeof(ifr));

758

  // go that route.

653

    strncpy ((char *)ifr.ifr_name, m_deviceName.c_str (), IFNAMSIZ);

759

//

654

655

    NS_LOG_LOGIC ("Getting MAC address");

656

    int32_t rc = ioctl (m_sock, SIOCGIFHWADDR, &ifr);

657

    if (rc == -1)

658

659

        NS_FATAL_ERROR ("EmuNetDevice::SendFrom(): Can't get MAC address");

660

661

662

    std::ostringstream oss;

663

    oss << std::hex <<

664

      (ifr.ifr_hwaddr.sa_data[0] & 0xff) << ":" <<

665

      (ifr.ifr_hwaddr.sa_data[1] & 0xff) << ":" <<

666

      (ifr.ifr_hwaddr.sa_data[2] & 0xff) << ":" <<

667

      (ifr.ifr_hwaddr.sa_data[3] & 0xff) << ":" <<

668

      (ifr.ifr_hwaddr.sa_data[4] & 0xff) << ":" <<

669

      (ifr.ifr_hwaddr.sa_data[5] & 0xff) << std::dec;

670

671

    NS_LOG_LOGIC ("Fixup source to HW MAC " << oss.str ());

672

    source = Mac48Address (oss.str ().c_str ());

673

    NS_LOG_LOGIC ("source now " << source);

674

675

#endif

676

677

  LlcSnapHeader llc;

760

  LlcSnapHeader llc;

678

  llc.SetType (protocolNumber);

761

  llc.SetType (protocolNumber);

679

  packet->AddHeader (llc);

762

  packet->AddHeader (llc);

Lines 688-698 EmuNetDevice::SendFrom (Ptr<Packet> pack	Link Here

688

  trailer.CalcFcs (packet);

771

  trailer.CalcFcs (packet);

689

  packet->AddTrailer (trailer);

772

  packet->AddTrailer (trailer);

690

773

774

//

775

  // there's not much meaning associated with the different layers in this

776

  // device, so don't be surprised when they're all stacked together in

777

  // essentially one place.  We do this for trace consistency across devices.

778

//

779

  m_macTxTrace (packet);

780

691

//

781

//

692

  // Enqueue and dequeue the packet to hit the tracing hooks.

782

  // Enqueue and dequeue the packet to hit the queue tracing hooks.

693

//

783

//

694

  m_queue->Enqueue (packet);

784

  m_queue->Enqueue (packet);

695

  packet = m_queue->Dequeue ();

785

  packet = m_queue->Dequeue ();

786

  NS_ASSERT_MSG (packet, "EmuNetDevice::SendFrom(): packet zero from queue");

787

788

  m_promiscSnifferTrace (packet);

789

  m_snifferTrace (packet);

790

696

791

697

  struct sockaddr_ll ll;

792

  struct sockaddr_ll ll;

698

  bzero (&ll, sizeof (ll));

793

  bzero (&ll, sizeof (ll));

Lines 703-712 EmuNetDevice::SendFrom (Ptr<Packet> pack	Link Here

703

798

704

  NS_LOG_LOGIC ("calling sendto");

799

  NS_LOG_LOGIC ("calling sendto");

705

800

801

  m_phyTxStartTrace (packet);

802

706

  int32_t rc;

803

  int32_t rc;

707

  rc = sendto (m_sock, packet->PeekData (), packet->GetSize (), 0, reinterpret_cast<struct sockaddr *> (&ll), sizeof (ll));

804

  rc = sendto (m_sock, packet->PeekData (), packet->GetSize (), 0, reinterpret_cast<struct sockaddr *> (&ll), sizeof (ll));

805

  NS_LOG_LOGIC ("sendto returns " << rc);

708

806

709

  NS_LOG_LOGIC ("sendto returns " << rc);

807

  m_phyTxTrace (packet);

710

808

711

  return rc == -1 ? false : true;

809

  return rc == -1 ? false : true;

712

810




  Ptr<Queue> m_queue;

  /**
   * The trace source fired when packets come into the "top" of the device
   * at the L3/L2 transition, before being queued for transmission.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macTxTrace;

  /**
   * The trace source fired when packets coming into the "top" of the device
   * at the L3/L2 transition are dropped before being queued for transmission.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macTxDropTrace;

  /**
   * The trace source fired for packets successfully received by the device
   * immediately before being forwarded up to higher layers (at the L2/L3 
   * transition).
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macRxTrace;

  /**
   * The trace source fired when a packet starts the transmission process on
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxStartTrace;

  /**
   * The trace source fired when a packet ends the transmission process on
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxTrace;

  /**
   * The trace source fired when the phy layer drops a packet as it tries
   * to transmit it.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxDropTrace;

  /**
   * The trace source fired when a packet ends the reception process from
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxTrace;

  /**
   * The trace source fired when a packet starts the reception process from
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxStartTrace;

  /**
   * The trace source fired when the phy layer drops a packet it has received.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxDropTrace;

  /**
   * A trace source that emulates a non-promiscuous protocol sniffer connected 
   * to the device.  Unlike your average everyday sniffer, this trace source 
   * will not fire on PACKET_OTHERHOST events.
   *
   * On the transmit size, this trace hook will fire after a packet is dequeued
   * from the device queue for transmission.  In Linux, for example, this would
   * correspond to the point just before a device hard_start_xmit where 
   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET 
   * ETH_P_ALL handlers.
   *
   * On the receive side, this trace hook will fire when a packet is received,
   * just before the receive callback is executed.  In Linux, for example, 
   * this would correspond to the point at which the packet is dispatched to 
   * packet sniffers in netif_receive_skb.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_snifferTrace;

  /**
   * A trace source that emulates a promiscuous mode protocol sniffer connected
   * to the device.  This trace source fire on packets destined for any host
   * just like your average everyday packet sniffer.
   *
   * On the transmit size, this trace hook will fire after a packet is dequeued
   * from the device queue for transmission.  In Linux, for example, this would
   * correspond to the point just before a device hard_start_xmit where 
   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET 
   * ETH_P_ALL handlers.
   *
   * On the receive side, this trace hook will fire when a packet is received,
   * just before the receive callback is executed.  In Linux, for example, 
   * this would correspond to the point at which the packet is dispatched to 
   * packet sniffers in netif_receive_skb.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_promiscSnifferTrace;

  /**
   * Time to start spinning up the device




  void Attach (Ptr<PointToPointNetDevice> device);

  /**
   * \brief Transmit a packet over this channel
   * \param p Packet to transmit
   * \param src Source PointToPointNetDevice
   * \param txTime Transmit time to apply
   * \returns true if successful (currently always true)
   */
  bool TransmitStart (Ptr<Packet> p, Ptr<PointToPointNetDevice> src, Time txTime);
    Time txTime);

  /**
   * \brief Get number of devices on this channel




                   PointerValue (),
                   MakePointerAccessor (&PointToPointNetDevice::m_receiveErrorModel),
                   MakePointerChecker<ErrorModel> ())
    .AddAttribute ("TxQueue",
                   "A queue to use as the transmit queue in the device.",
                   PointerValue (),
                   MakePointerAccessor (&PointToPointNetDevice::m_queue),
                   MakePointerChecker<Queue> ())
    .AddAttribute ("InterframeGap", 
                   "The time to wait between packet (frame) transmissions",
                   TimeValue (Seconds (0.0)),
                   MakeTimeAccessor (&PointToPointNetDevice::m_tInterframeGap),
                   MakeTimeChecker ())
    .AddTraceSource ("Rx", 
                     "Trace source indicating reception of packet from the PointToPointChannel.",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_rxTrace))
    .AddTraceSource ("Drop",
                     "Trace source indicating a packet was discarded due to a ReceiveErrorModel decision.",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_dropTrace))

    //
    // Transmit queueing discipline for the device which includes its own set
    // of trace hooks.
    //
    .AddAttribute ("TxQueue", 
                   "A queue to use as the transmit queue in the device.",
                   PointerValue (),
                   MakePointerAccessor (&PointToPointNetDevice::m_queue),
                   MakePointerChecker<Queue> ())

    //
    // Trace sources at the "top" of the net device, where packets transition
    // to/from higher layers.
    //
    .AddTraceSource ("MacTx", 
                     "Trace source indicating a packet has arrived for transmission by this device",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_macTxTrace))
    .AddTraceSource ("MacTxDrop", 
                     "Trace source indicating a packet has been dropped by the device before transmission",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_macTxDropTrace))
    .AddTraceSource ("MacRx", 
                     "Trace source indicating a packet has been received by this device and is being forwarded up the stack",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_macRxTrace))
    //
    // Trace souces at the "bottom" of the net device, where packets transition
    // to/from the channel.
    //
    .AddTraceSource ("PhyTxStart", 
                     "Trace source indicating a packet has begun transmitting over the channel",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_phyTxStartTrace))
    .AddTraceSource ("PhyTx", 
                     "Trace source indicating a packet has been completely transmitted over the channel",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_phyTxTrace))
    .AddTraceSource ("PhyTxDrop", 
                     "Trace source indicating a packet has been dropped by the device during transmission",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_phyTxDropTrace))
    .AddTraceSource ("PhyRxStart", 
                     "Trace source indicating a packet has begun being received by the device",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_phyRxStartTrace))
    .AddTraceSource ("PhyRx", 
                     "Trace source indicating a packet has been completely received by the device",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_phyRxTrace))
    .AddTraceSource ("PhyRxDrop", 
                     "Trace source indicating a packet has been dropped by the device during reception",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_phyRxDropTrace))

    //
    // Trace sources designed to simulate a packet sniffer facility (tcpdump).
    //
    .AddTraceSource ("Sniffer", 
                     "Trace source simulating a non-promiscuous packet sniffer attached to the device",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_snifferTrace))
    .AddTraceSource ("PromiscSniffer", 
                     "Trace source simulating a promiscuous packet sniffer attached to the device",
                     MakeTraceSourceAccessor (&PointToPointNetDevice::m_promiscSnifferTrace))
    ;
  return tid;
}

  m_txMachineState (READY),
  m_channel (0), 
  m_name (""),
  m_linkUp (false),
  m_currentPkt (0)
{
  NS_LOG_FUNCTION (this);


PointToPointNetDevice::AddHeader(Ptr<Packet> p, uint16_t protocolNumber)
{
  NS_LOG_FUNCTION_NOARGS ();
  NS_ASSERT_MSG (protocolNumber == 0x800, "PointToPointNetDevice::AddHeader(): protocolNumber must be 0x800");
    "PointToPointNetDevice::AddHeader(): protocolNumber must be 0x800");
  PppHeader ppp;
  p->AddHeader (ppp);
}

  m_node = 0;
  m_channel = 0;
  m_receiveErrorModel = 0;
  m_currentPkt = 0;
  NetDevice::DoDispose ();
}


{
  NS_LOG_FUNCTION (this << p);
  NS_LOG_LOGIC ("UID is " << p->GetUid () << ")");

  //
  // This function is called to start the process of transmitting a packet.
  // We need to tell the channel that we've started wiggling the wire and
  // schedule an event that will be executed when the transmission is complete.
  //
  NS_ASSERT_MSG(m_txMachineState == READY, "Must be READY to transmit");
  m_txMachineState = BUSY;
  m_phyTxTrace (m_currentPkt);
  m_currentPkt = p;

  Time txTime = Seconds (m_bps.CalculateTxTime(p->GetSize()));
  Time txCompleteTime = txTime + m_tInterframeGap;

  NS_LOG_LOGIC ("Schedule TransmitCompleteEvent in " << txCompleteTime.GetSeconds () << "sec");
  Simulator::Schedule (txCompleteTime, &PointToPointNetDevice::TransmitComplete, this);

  bool result = m_channel->TransmitStart(p, this, txTime); 
  if (result == false)
    {
      m_phyTxDropTrace (p);
    }
  return result;
}

  void 
PointToPointNetDevice::TransmitComplete (void)
{
  NS_LOG_FUNCTION_NOARGS ();

  //
  // This function is called to when we're all done transmitting a packet.
  // We try and pull another packet off of the transmit queue.  If the queue
  // is empty, we are done, otherwise we need to start transmitting the
  // next packet.
  //
  NS_ASSERT_MSG(m_txMachineState == BUSY, "Must be BUSY if transmitting");
  m_txMachineState = READY;

  NS_ASSERT_MSG (m_currentPkt != 0, "PointToPointNetDevice::TransmitComplete(): m_currentPkt zero");

  m_phyTxTrace (m_currentPkt);
  m_currentPkt = 0;

  Ptr<Packet> p = m_queue->Dequeue ();
  if (p == 0)
    {
      //
      // No packet was on the queue, so we just exit.
      //
      return;
    }

  //
  // Got another packet off of the queue, so start the transmit process agin.
  //
  m_snifferTrace (p);
  TransmitStart(p);
}



  m_channel->Attach(this);

  //
  // This device is up whenever it is attached to a channel.  A better plan
  // would be to have the link come up when both devices are attached, but this
  // is not done for now.
  //
  NotifyLinkUp ();
  return true;
}


  if (m_receiveErrorModel && m_receiveErrorModel->IsCorrupt (packet) ) 
    {
      // 
      // If we have an error model and it indicates that it is time to lose a
      // corrupted packet, don't forward this packet up, let it go.
      //
      m_phyRxDropTrace (packet);
    }
  else 
    {
      // 
      // Hit the trace hooks.  All of these hooks are in the same place in this 
      // device becuase it is so simple, but this is not usually the case.  
      //
      m_snifferTrace (packet);
      m_phyRxTrace (packet);
      m_macRxTrace (packet);

      //
      // Strip off the point-to-point protocol header and forward this packet
      // up the protocol stack.  Since this is a simple point-to-point link,
      // there is no difference in what the promisc callback sees and what the
      // normal receive callback sees.
      //
      ProcessHeader(packet, protocol);

      if (!m_promiscCallback.IsNull ())
        {
          Ptr<Packet> pktCopy = packet->Copy ();
          m_promiscCallback (this, pktCopy, protocol, GetRemote (), GetAddress (), NetDevice::PACKET_HOST);
        }

      m_rxCallback (this, packet, protocol, GetRemote ());
    }
}


  NS_LOG_LOGIC ("p=" << packet << ", dest=" << &dest);
  NS_LOG_LOGIC ("UID is " << packet->GetUid ());

  //
  // If IsLinkUp() is false it means there is no channel to send any packet 
  // over so we just hit the drop trace on the packet and return an error.
  //
  if (IsLinkUp () == false)
    {
      m_macTxDropTrace (packet);
      return false;
    }

  //
  // Stick a point to point protocol header on the packet in preparation for
  // shoving it out the door.
  //
  AddHeader(packet, protocolNumber);

  m_macTxTrace (packet);

  //
  // If there's a transmission in progress, we enque the packet for later
  // transmission; otherwise we send it now.
  //
  if (m_txMachineState == READY) 
    {
      // 
      // Even if the transmitter is immediately available, we still enqueue and
      // dequeue the packet to hit the tracing hooks.
      //
      m_queue->Enqueue (packet);
      packet = m_queue->Dequeue ();
      m_snifferTrace (packet);
      return TransmitStart (packet);
    }
  else




  Ptr<Queue> m_queue;

  /**
   * The trace source for the packet reception events that the device can
   * fire.
   *
   * @see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_rxTrace;

  /**
   * The trace source for the packet drop events that the device can
   * fire.
   *
   * @see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_dropTrace;

  /**
   * Error model for receive packet events
   */
  Ptr<ErrorModel> m_receiveErrorModel;

  /**
   * The trace source fired when packets come into the "top" of the device
   * at the L3/L2 transition, before being queued for transmission.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macTxTrace;

  /**
   * The trace source fired when packets coming into the "top" of the device
   * at the L3/L2 transition are dropped before being queued for transmission.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macTxDropTrace;

  /**
   * The trace source fired for packets successfully received by the device
   * immediately before being forwarded up to higher layers (at the L2/L3 
   * transition).
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_macRxTrace;

  /**
   * The trace source fired when a packet starts the transmission process on
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxStartTrace;

  /**
   * The trace source fired when a packet ends the transmission process on
   * the medium.  This happens immediately after the device has completed
   * packet transmission and has stopped "wiggling" the wire.  N.B. This
   * is not the same time that the packet will be received on a remote device
   * as that time includes a speed-of-light delay.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxTrace;

  /**
   * The trace source fired when the phy layer drops a packet before it tries
   * to transmit it.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxDropTrace;

  /**
   * The trace source fired when a packet starts the reception process from
   * the medium -- when the simulated first bit(s) arrive.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxStartTrace;

  /**
   * The trace source fired when a packet ends the reception process from
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxTrace;

  /**
   * The trace source fired when the phy layer drops a packet it has received.
   * This happens if the receiver is not enabled or the error model is active
   * and indicates that the packet is corrupt.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxDropTrace;

  /**
   * A trace source that emulates a non-promiscuous protocol sniffer connected 
   * to the device.  Unlike your average everyday sniffer, this trace source 
   * will not fire on PACKET_OTHERHOST events.
   *
   * On the transmit size, this trace hook will fire after a packet is dequeued
   * from the device queue for transmission.  In Linux, for example, this would
   * correspond to the point just before a device hard_start_xmit where 
   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET 
   * ETH_P_ALL handlers.
   *
   * On the receive side, this trace hook will fire when a packet is received,
   * just before the receive callback is executed.  In Linux, for example, 
   * this would correspond to the point at which the packet is dispatched to 
   * packet sniffers in netif_receive_skb.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_snifferTrace;

  /**
   * A trace source that emulates a promiscuous mode protocol sniffer connected
   * to the device.  This trace source fire on packets destined for any host
   * just like your average everyday packet sniffer.
   *
   * On the transmit size, this trace hook will fire after a packet is dequeued
   * from the device queue for transmission.  In Linux, for example, this would
   * correspond to the point just before a device hard_start_xmit where 
   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET 
   * ETH_P_ALL handlers.
   *
   * On the receive side, this trace hook will fire when a packet is received,
   * just before the receive callback is executed.  In Linux, for example, 
   * this would correspond to the point at which the packet is dispatched to 
   * packet sniffers in netif_receive_skb.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_promiscSnifferTrace;

  Ptr<Node> m_node;
  Mac48Address m_address;

   * Ethernet.
   */
  uint32_t m_mtu;

  Ptr<Packet> m_currentPkt;
};

} // namespace ns3




#include "mac-rx-middle.h"
#include "wifi-phy.h"
#include "dcf-manager.h"
#include "wifi-mac-trailer.h"
#include "ns3/pointer.h"
#include "ns3/packet.h"
#include "ns3/log.h"

      destination->RecordDisassociated ();
    }

  m_macTxTrace (packet);
  m_dca->Queue (packet, hdr);
}
bool 

AdhocWifiMac::ForwardUp (Ptr<Packet> packet, WifiMacHeader const *hdr)
{
  NS_LOG_DEBUG ("received size="<<packet->GetSize ()<<", from="<<hdr->GetAddr2 ());
  m_macRxTrace (packet);
  m_upCallback (packet, hdr->GetAddr2 (), hdr->GetAddr1 ());
}
Ptr<DcaTxop>

(-)a/src/devices/wifi/mac-low.cc (+4 lines)

Lines 840-845 MacLow::ForwardDown (Ptr<const Packet> p	Link Here

840

*/

840

*/

841

  Time txDuration = m_phy->CalculateTxDuration (packet->GetSize (), txMode, WIFI_PREAMBLE_LONG);

841

  Time txDuration = m_phy->CalculateTxDuration (packet->GetSize (), txMode, WIFI_PREAMBLE_LONG);

842

  Simulator::Schedule (txDuration, &MacLow::NotifyNav, this, *hdr, txMode, WIFI_PREAMBLE_LONG);

842

  Simulator::Schedule (txDuration, &MacLow::NotifyNav, this, *hdr, txMode, WIFI_PREAMBLE_LONG);

843

/*

844

   * Tell the phy when we expect the packet has completely been sent -- for tracing

845

*/

846

  Simulator::Schedule (txDuration, &WifiPhy::SendDone, m_phy, packet);

843

847

844

848

845

void

849

void

(-)a/src/devices/wifi/nqap-wifi-mac.cc (+7 lines)

Lines 30-35	Link Here

#include "dcf-manager.h"

#include "dcf-manager.h"

#include "mac-rx-middle.h"

#include "mac-rx-middle.h"

#include "mac-low.h"

#include "mac-low.h"

#include "wifi-mac-trailer.h"

#include "ns3/pointer.h"

#include "ns3/pointer.h"

NS_LOG_COMPONENT_DEFINE ("NqapWifiMac");

NS_LOG_COMPONENT_DEFINE ("NqapWifiMac");

Lines 285-292 NqapWifiMac::ForwardUp (Ptr<Packet> pack	Link Here

285

NqapWifiMac::ForwardUp (Ptr<Packet> packet, Mac48Address from, Mac48Address to)

286

NqapWifiMac::ForwardUp (Ptr<Packet> packet, Mac48Address from, Mac48Address to)

286

287

  NS_LOG_FUNCTION (this << packet << from);

288

  NS_LOG_FUNCTION (this << packet << from);

289

  m_macRxTrace (packet);

288

  m_upCallback (packet, from, to);

290

  m_upCallback (packet, from, to);

289

291

292

290

void

293

void

291

NqapWifiMac::ForwardDown (Ptr<const Packet> packet, Mac48Address from, Mac48Address to)

294

NqapWifiMac::ForwardDown (Ptr<const Packet> packet, Mac48Address from, Mac48Address to)

292

295

Lines 298-303 NqapWifiMac::ForwardDown (Ptr<const Pack	Link Here

298

  hdr.SetAddr3 (from);

301

  hdr.SetAddr3 (from);

299

  hdr.SetDsFrom ();

302

  hdr.SetDsFrom ();

300

  hdr.SetDsNotTo ();

303

  hdr.SetDsNotTo ();

304

305

  m_macTxTrace (packet);

301

  m_dca->Queue (packet, hdr);

306

  m_dca->Queue (packet, hdr);

302

307

303

void

308

void

Lines 472-482 NqapWifiMac::Receive (Ptr<Packet> packet	Link Here

472

477

473

          // this is an AP-to-AP frame

478

          // this is an AP-to-AP frame

474

          // we ignore for now.

479

          // we ignore for now.

480

          m_macRxDropTrace (packet);

475

481

476

      else

482

      else

477

483

478

          // we can ignore these frames since

484

          // we can ignore these frames since

479

          // they are not targeted at the AP

485

          // they are not targeted at the AP

486

          m_macRxDropTrace (packet);

480

487

481

488

482

  else if (hdr->IsMgt ())

489

  else if (hdr->IsMgt ())




#include "mac-low.h"
#include "dcf-manager.h"
#include "mac-rx-middle.h"
#include "wifi-mac-trailer.h"
#include "ns3/trace-source-accessor.h"
#include "ns3/pointer.h"


NqstaWifiMac::ForwardUp (Ptr<Packet> packet, Mac48Address from, Mac48Address to)
{
  NS_LOG_FUNCTION (this << packet << from << to);
  m_macRxTrace (packet);
  m_forwardUp (packet, from, to);
}
void

void 
NqstaWifiMac::Enqueue (Ptr<const Packet> packet, Mac48Address to, Mac48Address from)
{
  NS_FATAL_ERROR ("Qsta does not support SendTo");
}

void 
NqstaWifiMac::Enqueue (Ptr<const Packet> packet, Mac48Address to)
{
  NS_LOG_FUNCTION (this << packet << to);
  if (!IsAssociated ()) 
    {
      m_macTxDropTrace (packet);
      TryToEnsureAssociated ();
      return;
    }

  hdr.SetAddr3 (to);
  hdr.SetDsNotFrom ();
  hdr.SetDsTo ();

  m_macTxTrace (packet);
  m_dca->Queue (packet, hdr);
}

bool 
NqstaWifiMac::SupportsSendFrom (void) const
{
  //
  // The 802.11 MAC protocol has no way to support bridging outside of
  // infrastructure mode
  //
  return false;
}  



           !hdr->GetAddr1 ().IsGroup ()) 
    {
      NS_LOG_LOGIC ("packet is not for us");
      m_macRxDropTrace (packet);
    } 
  else if (hdr->IsData ()) 
    {
      if (!IsAssociated ())
        {
          NS_LOG_LOGIC ("Received data frame while not associated: ignore");
          m_macRxDropTrace (packet);
          return;
        }
      if (!(hdr->IsFromDs () && !hdr->IsToDs ()))
        {
          NS_LOG_LOGIC ("Received data frame not from the DS: ignore");
          m_macRxDropTrace (packet);
          return;
        }
      if (hdr->GetAddr2 () != GetBssid ())
        {
          NS_LOG_LOGIC ("Received data frame not from the the BSS we are associated with: ignore");
          m_macRxDropTrace (packet);
          return;
        }

      ForwardUp (packet, hdr->GetAddr3 (), hdr->GetAddr1 ());
    } 
  else if (hdr->IsProbeReq () ||

      /* this is a frame aimed at an AP.
       * so we can safely ignore it.
       */
      m_macRxDropTrace (packet);
    } 
  else if (hdr->IsBeacon ()) 
    {




 */
#include "wifi-mac.h"
#include "ns3/uinteger.h"
#include "ns3/trace-source-accessor.h"

namespace ns3 {


		   MakeSsidAccessor (&WifiMac::GetSsid,
				     &WifiMac::SetSsid),
		   MakeSsidChecker ())
    .AddTraceSource ("MacTx", 
                     "A packet has been received from higher layers and is being processed in preparation for "
                     "queueing for transmission.",
                     MakeTraceSourceAccessor (&WifiMac::m_macTxTrace))
    .AddTraceSource ("MacTxDrop", 
                     "A packet has been dropped in the MAC layer before being queued for transmission.",
                     MakeTraceSourceAccessor (&WifiMac::m_macTxDropTrace))
    .AddTraceSource ("MacRx", 
                     "A packet has been received by this device, has been passed up from the physical layer "
                     "and is being forwarded up the local protocol stack.",
                     MakeTraceSourceAccessor (&WifiMac::m_macRxTrace))
    .AddTraceSource ("MacRxDrop", 
                     "A packet has been dropped in the MAC layer after it has been passed up from the physical "
                     "layer.",
                     MakeTraceSourceAccessor (&WifiMac::m_macRxDropTrace))
    .AddTraceSource ("Sniffer", 
                     "Trace source simulating a non-promiscuous packet sniffer attached to the device",
                     MakeTraceSourceAccessor (&WifiMac::m_snifferTrace))
    ;

  return tid;
}


  return m_maxMsduSize;
}

void
WifiMac::SnifferTrace (Ptr<const Packet> packet)
{
  m_snifferTrace (packet);
}


} // namespace ns3

(-)a/src/devices/wifi/wifi-mac.h (-3 / +62 lines)

Lines 176-185 public:	Link Here

176

   * \param linkDown the callback to invoke when the link becomes down.

176

   * \param linkDown the callback to invoke when the link becomes down.

177

*/

177

*/

178

  virtual void SetLinkDownCallback (Callback<void> linkDown) = 0;

178

  virtual void SetLinkDownCallback (Callback<void> linkDown) = 0;

179

180

/*

181

   * Let the net device hit a trace hook.  This is done to group the high-level

182

   * trace sources all in one place for ease of use.

183

*/

184

  void SnifferTrace (Ptr<const Packet> packet);

185

179

private:

186

private:

180

181

182

183

  static Time GetDefaultMaxPropagationDelay (void);

187

  static Time GetDefaultMaxPropagationDelay (void);

184

  static Time GetDefaultSlot (void);

188

  static Time GetDefaultSlot (void);

185

  static Time GetDefaultSifs (void);

189

  static Time GetDefaultSifs (void);

Lines 189-194 private:	Link Here

189

193

190

  Time m_maxPropagationDelay;

194

  Time m_maxPropagationDelay;

191

  uint32_t m_maxMsduSize;

195

  uint32_t m_maxMsduSize;

196

197

protected:

198

199

/**

200

   * The trace source fired when packets come into the "top" of the device

201

   * at the L3/L2 transition, before being queued for transmission.

202

203

   * \see class CallBackTraceSource

204

*/

205

  TracedCallback<Ptr<const Packet> > m_macTxTrace;

206

207

/**

208

   * The trace source fired when packets coming into the "top" of the device

209

   * are dropped at the MAC layer during transmission.

210

211

   * \see class CallBackTraceSource

212

*/

213

  TracedCallback<Ptr<const Packet> > m_macTxDropTrace;

214

215

/**

216

   * The trace source fired for packets successfully received by the device

217

   * immediately before being forwarded up to higher layers (at the L2/L3

218

   * transition).

219

220

   * \see class CallBackTraceSource

221

*/

222

  TracedCallback<Ptr<const Packet> > m_macRxTrace;

223

224

/**

225

   * The trace source fired when packets coming into the "top" of the device

226

   * are dropped at the MAC layer during reception.

227

228

   * \see class CallBackTraceSource

229

*/

230

  TracedCallback<Ptr<const Packet> > m_macRxDropTrace;

231

232

/**

233

   * A trace source that emulates a non-promiscuous protocol sniffer connected

234

   * to the device.  Unlike your average everyday sniffer, this trace source

235

   * will not fire on PACKET_OTHERHOST events.

236

237

   * On the transmit size, this trace hook will fire after a packet is dequeued

238

   * from the device queue for transmission.  In Linux, for example, this would

239

   * correspond to the point just before a device hard_start_xmit where

240

   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET

241

   * ETH_P_ALL handlers.

242

243

   * On the receive side, this trace hook will fire when a packet is received,

244

   * just before the receive callback is executed.  In Linux, for example,

245

   * this would correspond to the point at which the packet is dispatched to

246

   * packet sniffers in netif_receive_skb.

247

248

   * \see class CallBackTraceSource

249

*/

250

  TracedCallback<Ptr<const Packet> > m_snifferTrace;

192

};

251

};

193

252

194

} // namespace ns3

253

} // namespace ns3

(-)a/src/devices/wifi/wifi-net-device.cc (-6 / +33 lines)

Lines 23-28	Link Here

#include "wifi-remote-station-manager.h"

#include "wifi-remote-station-manager.h"

#include "wifi-channel.h"

#include "wifi-channel.h"

#include "ns3/llc-snap-header.h"

#include "ns3/llc-snap-header.h"

#include "ns3/ethernet-header.h"

#include "ns3/ethernet-trailer.h"

#include "ns3/packet.h"

#include "ns3/packet.h"

#include "ns3/uinteger.h"

#include "ns3/uinteger.h"

#include "ns3/pointer.h"

#include "ns3/pointer.h"

Lines 57-66 WifiNetDevice::GetTypeId (void)	Link Here

                   MakePointerAccessor (&WifiNetDevice::SetRemoteStationManager,

                   MakePointerAccessor (&WifiNetDevice::SetRemoteStationManager,

                                        &WifiNetDevice::GetRemoteStationManager),

                                        &WifiNetDevice::GetRemoteStationManager),

                   MakePointerChecker<WifiRemoteStationManager> ())

                   MakePointerChecker<WifiRemoteStationManager> ())

    .AddTraceSource ("Rx", "Received payload from the MAC layer.",

                     MakeTraceSourceAccessor (&WifiNetDevice::m_rxLogger))

    .AddTraceSource ("Tx", "Send payload to the MAC layer.",

                     MakeTraceSourceAccessor (&WifiNetDevice::m_txLogger))

  return tid;

  return tid;

Lines 243-253 WifiNetDevice::IsBridge (void) const	Link Here

243

  return false;

241

  return false;

244

242

245

bool

243

bool

246

WifiNetDevice::Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)

244

WifiNetDevice::Send (Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber)

247

245

248

  NS_ASSERT (Mac48Address::IsMatchingType (dest));

246

  NS_ASSERT (Mac48Address::IsMatchingType (dest));

249

247

250

  Mac48Address realTo = Mac48Address::ConvertFrom (dest);

248

  Mac48Address realTo = Mac48Address::ConvertFrom (dest);

249

  Mac48Address realFrom = Mac48Address::ConvertFrom (GetAddress ());

250

251

  SniffPacket (packet, realTo, realFrom, protocolNumber);

251

252

  LlcSnapHeader llc;

253

  LlcSnapHeader llc;

253

  llc.SetType (protocolNumber);

254

  llc.SetType (protocolNumber);

Lines 303-315 WifiNetDevice::ForwardUp (Ptr<Packet> pa	Link Here

303

304

      type = NetDevice::PACKET_OTHERHOST;

305

      type = NetDevice::PACKET_OTHERHOST;

305

306

307

306

  if (type != NetDevice::PACKET_OTHERHOST)

308

  if (type != NetDevice::PACKET_OTHERHOST)

307

309

310

      SniffPacket (packet, to, from, llc.GetType ());

308

      m_forwardUp (this, packet, llc.GetType (), from);

311

      m_forwardUp (this, packet, llc.GetType (), from);

309

312

313

310

  if (!m_promiscRx.IsNull ())

314

  if (!m_promiscRx.IsNull ())

311

315

312

      m_promiscRx (this, packet, llc.GetType (), from, to, type);

316

      m_promiscRx (this, packet->Copy (), llc.GetType (), from, to, type);

313

317

314

318

315

319

Lines 341-346 WifiNetDevice::SendFrom (Ptr<Packet> pac	Link Here

341

  Mac48Address realTo = Mac48Address::ConvertFrom (dest);

345

  Mac48Address realTo = Mac48Address::ConvertFrom (dest);

342

  Mac48Address realFrom = Mac48Address::ConvertFrom (source);

346

  Mac48Address realFrom = Mac48Address::ConvertFrom (source);

343

347

348

  SniffPacket (packet, realTo, realFrom, protocolNumber);

349

344

  LlcSnapHeader llc;

350

  LlcSnapHeader llc;

345

  llc.SetType (protocolNumber);

351

  llc.SetType (protocolNumber);

346

  packet->AddHeader (llc);

352

  packet->AddHeader (llc);

Lines 364-368 WifiNetDevice::SupportsSendFrom (void) c	Link Here

364

  return m_mac->SupportsSendFrom ();

370

  return m_mac->SupportsSendFrom ();

365

371

366

372

373

void

374

WifiNetDevice::SniffPacket (Ptr<const Packet> packet, Mac48Address to, Mac48Address from, uint16_t type)

375

376

  Ptr<Packet> copy = packet->Copy ();

377

  EthernetHeader header (false);

378

  header.SetSource (from);

379

  header.SetDestination (to);

380

381

  LlcSnapHeader llc;

382

  llc.SetType (type);

383

  copy->AddHeader (llc);

384

385

  header.SetLengthType (copy->GetSize ());

386

  copy->AddHeader (header);

387

388

  EthernetTrailer trailer;

389

  trailer.CalcFcs (copy);

390

  copy->AddTrailer (trailer);

391

  m_mac->SnifferTrace (copy);

392

393

367

} // namespace ns3

394

} // namespace ns3

368

395




  Ptr<WifiRemoteStationManager> m_stationManager;
  NetDevice::ReceiveCallback m_forwardUp;
  NetDevice::PromiscReceiveCallback m_promiscRx;

  TracedCallback<Ptr<const Packet>, Mac48Address> m_rxLogger;
  TracedCallback<Ptr<const Packet>, Mac48Address> m_txLogger;

  /**
   * At the top of the MAC level, we do what many folks do and make the wifi 
   * packets look like Ethernet packets coming in and out of the "driver."  If
   * you are interested in seeing all of the wifi details, you should use the
   * much lower level PHY promiscuous sniffer trace.
   */
  void SniffPacket (Ptr<const Packet> packet, Mac48Address to, Mac48Address from, uint16_t type);

  uint32_t m_ifIndex;
  std::string m_name;
  bool m_linkUp;




{
  static TypeId tid = TypeId ("ns3::WifiPhy")
    .SetParent<Object> ()
    .AddTraceSource ("PhyTxStart", 
                     "Trace source indicating a packet has begun transmitting over the channel medium",
                     MakeTraceSourceAccessor (&WifiPhy::m_phyTxStartTrace))
    .AddTraceSource ("PhyTx", 
                     "Trace source indicating a packet has been completely transmitted over the channel",
                     MakeTraceSourceAccessor (&WifiPhy::m_phyTxTrace))
    .AddTraceSource ("PhyTxDrop", 
                     "Trace source indicating a packet has been dropped by the device during transmission",
                     MakeTraceSourceAccessor (&WifiPhy::m_phyTxDropTrace))
    .AddTraceSource ("PhyRxStart", 
                     "Trace source indicating a packet has begun being received from the channel medium by the device",
                     MakeTraceSourceAccessor (&WifiPhy::m_phyRxStartTrace))
    .AddTraceSource ("PhyRx", 
                     "Trace source indicating a packet has been completely received from the channel medium by the device",
                     MakeTraceSourceAccessor (&WifiPhy::m_phyRxTrace))
    .AddTraceSource ("PhyRxDrop", 
                     "Trace source indicating a packet has been dropped by the device during reception",
                     MakeTraceSourceAccessor (&WifiPhy::m_phyRxDropTrace))
    .AddTraceSource ("PromiscSniffer", 
                     "Trace source simulating a promiscuous packet sniffer attached to the device",
                     MakeTraceSourceAccessor (&WifiPhy::m_promiscSnifferTrace))
    ;
  return tid;
}

(-)a/src/devices/wifi/wifi-phy.h (+77 lines)

Lines 30-35	Link Here

#include "wifi-mode.h"

#include "wifi-mode.h"

#include "wifi-preamble.h"

#include "wifi-preamble.h"

#include "wifi-phy-standard.h"

#include "wifi-phy-standard.h"

#include "ns3/traced-callback.h"

namespace ns3 {

namespace ns3 {

Lines 79-84 public:	Link Here

   * unless they have received a cca busy report.

   * unless they have received a cca busy report.

*/

*/

  virtual void NotifyTxStart (Time duration) = 0;

  virtual void NotifyTxStart (Time duration) = 0;

/**

/**

   * \param duration the expected busy duration.

   * \param duration the expected busy duration.

Lines 171-176 public:	Link Here

171

   *        transmission power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels

173

   *        transmission power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels

172

*/

174

*/

173

  virtual void SendPacket (Ptr<const Packet> packet, WifiMode mode, enum WifiPreamble preamble, uint8_t txPowerLevel) = 0;

175

  virtual void SendPacket (Ptr<const Packet> packet, WifiMode mode, enum WifiPreamble preamble, uint8_t txPowerLevel) = 0;

176

177

/**

178

   * \param packet the packet that was sent

179

180

   * Tell the PHY-level that MAC low believes it should have just completed the send.

181

*/

182

  virtual void SendDone (Ptr<const Packet> packet) = 0;

174

183

175

/**

184

/**

176

   * \param listener the new listener

185

   * \param listener the new listener

Lines 250-255 public:	Link Here

250

  static WifiMode Get36mba (void);

259

  static WifiMode Get36mba (void);

251

  static WifiMode Get48mba (void);

260

  static WifiMode Get48mba (void);

252

  static WifiMode Get54mba (void);

261

  static WifiMode Get54mba (void);

262

263

protected:

264

/**

265

   * The trace source fired when a packet starts the transmission process on

266

   * the medium.

267

268

   * \see class CallBackTraceSource

269

*/

270

  TracedCallback<Ptr<const Packet> > m_phyTxStartTrace;

271

272

/**

273

   * The trace source fired when a packet ends the transmission process on

274

   * the medium.

275

276

   * \see class CallBackTraceSource

277

*/

278

  TracedCallback<Ptr<const Packet> > m_phyTxTrace;

279

280

/**

281

   * The trace source fired when the phy layer drops a packet as it tries

282

   * to transmit it.

283

284

   * \see class CallBackTraceSource

285

*/

286

  TracedCallback<Ptr<const Packet> > m_phyTxDropTrace;

287

288

/**

289

   * The trace source fired when a packet starts the reception process from

290

   * the medium.

291

292

   * \see class CallBackTraceSource

293

*/

294

  TracedCallback<Ptr<const Packet> > m_phyRxStartTrace;

295

296

/**

297

   * The trace source fired when a packet ends the reception process from

298

   * the medium.

299

300

   * \see class CallBackTraceSource

301

*/

302

  TracedCallback<Ptr<const Packet> > m_phyRxTrace;

303

304

/**

305

   * The trace source fired when the phy layer drops a packet it has received.

306

307

   * \see class CallBackTraceSource

308

*/

309

  TracedCallback<Ptr<const Packet> > m_phyRxDropTrace;

310

311

/**

312

   * A trace source that emulates a promiscuous mode protocol sniffer connected

313

   * to the device.  This trace source fire on packets destined for any host

314

   * just like your average everyday packet sniffer.

315

316

   * On the transmit size, this trace hook will fire after a packet is dequeued

317

   * from the device queue for transmission.  In Linux, for example, this would

318

   * correspond to the point just before a device hard_start_xmit where

319

   * dev_queue_xmit_nit is called to dispatch the packet to the PF_PACKET

320

   * ETH_P_ALL handlers.

321

322

   * On the receive side, this trace hook will fire when a packet is received,

323

   * just before the receive callback is executed.  In Linux, for example,

324

   * this would correspond to the point at which the packet is dispatched to

325

   * packet sniffers in netif_receive_skb.

326

327

   * \see class CallBackTraceSource

328

*/

329

  TracedCallback<Ptr<const Packet> > m_promiscSnifferTrace;

253

};

330

};

254

331

255

} // namespace ns3

332

} // namespace ns3




#include "ns3/enum.h"
#include "ns3/pointer.h"
#include "ns3/net-device.h"
#include "ns3/trace-source-accessor.h"
#include <math.h>

NS_LOG_COMPONENT_DEFINE ("YansWifiPhy");

  case YansWifiPhy::SYNC:
    NS_LOG_DEBUG ("drop packet because already in Sync (power="<<
                  rxPowerW<<"W)");
    m_phyRxDropTrace (packet);
    if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ()) 
      {
        // that packet will be noise _after_ the reception of the

  case YansWifiPhy::TX:
    NS_LOG_DEBUG ("drop packet because already in Tx (power="<<
                  rxPowerW<<"W)");
    m_phyRxDropTrace (packet);
    if (endRx > Simulator::Now () + m_state->GetDelayUntilIdle ()) 
      {
        // that packet will be noise _after_ the transmission of the

        // sync to signal
        m_state->SwitchToSync (rxDuration);
        NS_ASSERT (m_endSyncEvent.IsExpired ());
        m_phyRxStartTrace (packet);
        m_endSyncEvent = Simulator::Schedule (rxDuration, &YansWifiPhy::EndSync, this, 
                                              packet,
                                              event);

      {
        NS_LOG_DEBUG ("drop packet because signal power too Small ("<<
                      rxPowerW<<"<"<<m_edThresholdW<<")");
        m_phyRxDropTrace (packet);
        goto maybeCcaBusy;
      }
    break;

      m_state->SwitchMaybeToCcaBusy (delayUntilCcaEnd);
    }
}

void 
YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiMode txMode, WifiPreamble preamble, uint8_t txPower)
{

    {
      m_endSyncEvent.Cancel ();
    }
  m_phyTxStartTrace (packet);
  m_promiscSnifferTrace (packet);
  m_state->SwitchToTx (txDuration, packet, txMode, preamble, txPower);
  m_channel->Send (this, packet, GetPowerDbm (txPower) + m_txGainDb, txMode, preamble);
}

void
YansWifiPhy::SendDone (Ptr<const Packet> packet)
{
  m_phyTxTrace (packet);
}

uint32_t 

  
  if (m_random.GetValue () > snrPer.per) 
    {
      m_phyRxTrace (packet);
      m_promiscSnifferTrace (packet);
      m_state->SwitchFromSyncEndOk (packet, snrPer.snr, event->GetPayloadMode (), event->GetPreambleType ());
    } 
  else 
    {
      /* failure. */
      m_phyRxDropTrace (packet);
      m_state->SwitchFromSyncEndError (packet, snrPer.snr);
    }
}




  virtual void SetReceiveOkCallback (WifiPhy::SyncOkCallback callback);
  virtual void SetReceiveErrorCallback (WifiPhy::SyncErrorCallback callback);
  virtual void SendPacket (Ptr<const Packet> packet, WifiMode mode, enum WifiPreamble preamble, uint8_t txPowerLevel);
  virtual void SendDone (Ptr<const Packet> packet);
  virtual void RegisterListener (WifiPhyListener *listener);
  virtual bool IsStateCcaBusy (void);
  virtual bool IsStateIdle (void);

  void EndSync (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event);

private:
  /**
   * The trace source fired when a packet starts the transmission process on
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxStartTrace;

  /**
   * The trace source fired when a packet ends the transmission process on
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxTrace;

  /**
   * The trace source fired when the phy layer drops a packet as it tries
   * to transmit it.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyTxDropTrace;

  /**
   * The trace source fired when a packet ends the reception process from
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxTrace;

  /**
   * The trace source fired when a packet ends the reception process from
   * the medium.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxStartTrace;

  /**
   * The trace source fired when the phy layer drops a packet it has received.
   *
   * \see class CallBackTraceSource
   */
  TracedCallback<Ptr<const Packet> > m_phyRxDropTrace;

private:
  double   m_edThresholdW;
  double   m_ccaMode1ThresholdW;
  double   m_txGainDb;

  WifiPhyStandard m_standard;
  Ptr<WifiPhyStateHelper> m_state;
  InterferenceHelper m_interference;

};

} // namespace ns3




{
  SetDeviceAttribute (n1, v1);
}

void 
CsmaHelper::SetChannelParameter (std::string n1, const AttributeValue &v1)
{

  pcap->Open (oss.str ());
  pcap->WriteEthernetHeader ();
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::CsmaNetDevice/Sniffer";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&CsmaHelper::SniffEvent, pcap));
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::CsmaNetDevice/TxQueue/Enqueue";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&CsmaHelper::EnqueueEvent, pcap));
}

void 
CsmaHelper::EnablePcap (std::string filename, NetDeviceContainer d)
{

{
  Packet::EnablePrinting ();
  std::ostringstream oss;
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::CsmaNetDevice/MacRx";
  Config::Connect (oss.str (), MakeBoundCallback (&CsmaHelper::AsciiRxEvent, &os));
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::CsmaNetDevice/TxQueue/Enqueue";

}

void 
CsmaHelper::SniffEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
{
  writer->WritePacket (packet);
}

CsmaHelper::RxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
{
  writer->WritePacket (packet);
}
void 
CsmaHelper::AsciiEnqueueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet)
{




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

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

  static void AsciiRxEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);
  static void AsciiEnqueueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);
  static void AsciiDequeueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);
  static void AsciiDropEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

  ObjectFactory m_queueFactory;
  ObjectFactory m_deviceFactory;
  ObjectFactory m_channelFactory;




  pcap->WriteEthernetHeader ();

  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::EmuNetDevice/Sniffer";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&EmuHelper::SniffEvent, pcap));
  Config::ConnectWithoutContext (oss.str (), 
    MakeBoundCallback (&EmuHelper::RxEvent, pcap));

  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << 
    "/$ns3::EmuNetDevice/TxQueue/Enqueue";
  Config::ConnectWithoutContext (oss.str (), 
    MakeBoundCallback (&EmuHelper::EnqueueEvent, pcap));
}

  void 

  Packet::EnablePrinting ();
  std::ostringstream oss;

  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::EmuNetDevice/MacRx";
  Config::Connect (oss.str (), MakeBoundCallback (&EmuHelper::AsciiRxEvent, &os));
  Config::Connect (oss.str (), 
    MakeBoundCallback (&EmuHelper::AsciiRxEvent, &os));

  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::EmuNetDevice/TxQueue/Enqueue";
  Config::Connect (oss.str (), MakeBoundCallback (&EmuHelper::AsciiEnqueueEvent, &os));
  Config::Connect (oss.str (), 
    MakeBoundCallback (&EmuHelper::AsciiEnqueueEvent, &os));

  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::EmuNetDevice/TxQueue/Dequeue";
  Config::Connect (oss.str (), MakeBoundCallback (&EmuHelper::AsciiDequeueEvent, &os));
  Config::Connect (oss.str (), 
    MakeBoundCallback (&EmuHelper::AsciiDequeueEvent, &os));

  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::EmuNetDevice/TxQueue/Drop";
  Config::Connect (oss.str (), MakeBoundCallback (&EmuHelper::AsciiDropEvent, &os));
  Config::Connect (oss.str (), 
    MakeBoundCallback (&EmuHelper::AsciiDropEvent, &os));
}

  void 

}

  void 
EmuHelper::SniffEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
{
  NS_LOG_FUNCTION (writer << packet);
  writer->WritePacket (packet);
}

  void 
EmuHelper::RxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
{
  NS_LOG_FUNCTION (writer << packet);
  writer->WritePacket (packet);





private:
  Ptr<NetDevice> InstallPriv (Ptr<Node> node) const;
  static void SniffEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet);

  static void AsciiRxEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);
  static void AsciiEnqueueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);
  static void AsciiDequeueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);
  static void AsciiDropEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);
  static void AsciiDropEvent (std::ostream *os, std::string path, 
    Ptr<const Packet> packet);
  static void AsciiRxEvent (std::ostream *os, std::string path, 
    Ptr<const Packet> packet);

  ObjectFactory m_queueFactory;
  ObjectFactory m_deviceFactory;




  pcap->Open (oss.str ());
  pcap->WritePppHeader ();
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::PointToPointNetDevice/Sniffer";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&PointToPointHelper::SniffEvent, pcap));
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::PointToPointNetDevice/TxQueue/Enqueue";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&PointToPointHelper::EnqueueEvent, pcap));
}
void 
PointToPointHelper::EnablePcap (std::string filename, NetDeviceContainer d)

{
  Packet::EnablePrinting ();
  std::ostringstream oss;
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::PointToPointNetDevice/MacRx";
  Config::Connect (oss.str (), MakeBoundCallback (&PointToPointHelper::AsciiRxEvent, &os));
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::PointToPointNetDevice/TxQueue/Enqueue";

}

void 
PointToPointHelper::SniffEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
{
  writer->WritePacket (packet);
}
void 
PointToPointHelper::RxEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
{
  writer->WritePacket (packet);
}

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

Lines 261-273 public:	Link Here

261

262

private:

262

private:

263

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

263

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

264

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

265

264

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

266

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

265

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

267

  static void AsciiRxEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

266

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

267

  static void AsciiEnqueueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

268

  static void AsciiEnqueueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

268

  static void AsciiDequeueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

269

  static void AsciiDequeueEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

269

  static void AsciiDropEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

270

  static void AsciiDropEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

270

  static void AsciiRxEvent (std::ostream *os, std::string path, Ptr<const Packet> packet);

271

  ObjectFactory m_queueFactory;

272

  ObjectFactory m_queueFactory;

272

  ObjectFactory m_channelFactory;

273

  ObjectFactory m_channelFactory;

273

  ObjectFactory m_deviceFactory;

274

  ObjectFactory m_deviceFactory;




NS_LOG_COMPONENT_DEFINE ("WifiHelper");

namespace ns3 {

static void PcapSnifferEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
{
  writer->WritePacket (packet);
}

void 
WifiHelper::EnablePcap (std::string filename, uint32_t nodeid, uint32_t deviceid)
{
  std::ostringstream oss;
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WifiNetDevice/Mac/";
  Config::MatchContainer matches = Config::LookupMatches (oss.str ());
  if (matches.GetN () == 0)
    {
      return;
    }
  oss.str ("");
  oss << filename << "-" << nodeid << "-" << deviceid << ".pcap";
  Ptr<PcapWriter> pcap = Create<PcapWriter> ();
  pcap->Open (oss.str ());
  pcap->WriteEthernetHeader ();
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WifiNetDevice/Mac/Sniffer";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&PcapSnifferEvent, pcap));
}

void 
WifiHelper::EnablePcap (std::string filename, NetDeviceContainer d)
{
  for (NetDeviceContainer::Iterator i = d.Begin (); i != d.End (); ++i)
    {
      Ptr<NetDevice> dev = *i;
      EnablePcap (filename, dev->GetNode ()->GetId (), dev->GetIfIndex ());
    }
}
void
WifiHelper::EnablePcap (std::string filename, NodeContainer n)
{
  NetDeviceContainer devs;
  for (NodeContainer::Iterator i = n.Begin (); i != n.End (); ++i)
    {
      Ptr<Node> node = *i;
      for (uint32_t j = 0; j < node->GetNDevices (); ++j)
        {
          devs.Add (node->GetDevice (j));
        }
    }
  EnablePcap (filename, devs);
}

void
WifiHelper::EnablePcapAll (std::string filename)
{
  EnablePcap (filename, NodeContainer::GetGlobal ());
}

WifiPhyHelper::~WifiPhyHelper ()
{}




   * \returns a device container which contains all the devices created by this method.
   */
  NetDeviceContainer Install (const WifiPhyHelper &phy, std::string nodeName) const;
  /**
   * \param filename filename prefix to use for pcap files.
   * \param nodeid the id of the node to generate pcap output for.
   * \param deviceid the id of the device to generate pcap output for.
   *
   * Generate a pcap file which contains the link-level data observed
   * by the specified deviceid within the specified nodeid. The pcap
   * data is stored in the file prefix-nodeid-deviceid.pcap.
   *
   * This method should be invoked after the network topology has 
   * been fully constructed.
   */
  static void EnablePcap (std::string filename, uint32_t nodeid, uint32_t deviceid);
  /**
   * \param filename filename prefix to use for pcap files.
   * \param d container of devices of type ns3::WifiNetDevice
   *
   * Enable pcap output on each input device which is of the
   * ns3::WifiNetDevice type.
   */
  static void EnablePcap (std::string filename, NetDeviceContainer d);
  /**
   * \param filename filename prefix to use for pcap files.
   * \param n container of nodes.
   *
   * Enable pcap output on each device which is of the
   * ns3::WifiNetDevice type and which is located in one of the 
   * input nodes.
   */
  static void EnablePcap (std::string filename, NodeContainer n);
  /**
   * \param filename filename prefix to use for pcap files.
   *
   * Enable pcap output on each device which is of the
   * ns3::WifiNetDevice type
   */
  static void EnablePcapAll (std::string filename);

private:
  ObjectFactory m_stationManager;





namespace ns3 {

static void PcapSnifferEvent (Ptr<PcapWriter> writer, Ptr<const Packet> packet)
                            WifiMode mode, WifiPreamble preamble, 
                            uint8_t txLevel)
{
  writer->WritePacket (packet);
}

static void PcapPhyRxEvent (Ptr<PcapWriter> writer, 
                            Ptr<const Packet> packet, double snr, WifiMode mode, 
                            enum WifiPreamble preamble)
{
  writer->WritePacket (packet);
}

  pcap->Open (oss.str ());
  pcap->WriteWifiHeader ();
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WifiNetDevice/Phy/PromiscSniffer";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&PcapSnifferEvent, pcap));
  oss.str ("");
  oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::WifiNetDevice/Phy/State/RxOk";
  Config::ConnectWithoutContext (oss.str (), MakeBoundCallback (&PcapPhyRxEvent, pcap));
}
void 
YansWifiPhyHelper::EnablePcap (std::string filename, NetDeviceContainer d)

Return to bug 443