mirror of
https://gitlab.ibr.cs.tu-bs.de/tschuber/ns-3-leo.git
synced 2025-06-08 10:03:58 +02:00
init
This commit is contained in:
Tim Schubert
commit
13e4bf1aa7
21 changed files with 2601 additions and 0 deletions
742
model/isl-net-device.cc
Normal file
742
model/isl-net-device.cc
Normal file
|
|
@ -0,0 +1,742 @@
|
|||
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
|
||||
/*
|
||||
* Copyright (c) 2007, 2008 University of Washington
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation;
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include "ns3/log.h"
|
||||
#include "ns3/queue.h"
|
||||
#include "ns3/simulator.h"
|
||||
#include "ns3/mac48-address.h"
|
||||
#include "ns3/llc-snap-header.h"
|
||||
#include "ns3/error-model.h"
|
||||
#include "ns3/trace-source-accessor.h"
|
||||
#include "ns3/uinteger.h"
|
||||
#include "ns3/pointer.h"
|
||||
#include "ns3/net-device-queue-interface.h"
|
||||
#include "ns3/ppp-header.h"
|
||||
#include "isl-channel.h"
|
||||
#include "isl-net-device.h"
|
||||
|
||||
namespace ns3 {
|
||||
|
||||
NS_LOG_COMPONENT_DEFINE ("IslNetDevice");
|
||||
|
||||
NS_OBJECT_ENSURE_REGISTERED (IslNetDevice);
|
||||
|
||||
TypeId
|
||||
IslNetDevice::GetTypeId (void)
|
||||
{
|
||||
static TypeId tid = TypeId ("ns3::IslNetDevice")
|
||||
.SetParent<NetDevice> ()
|
||||
.SetGroupName ("Leo")
|
||||
.AddConstructor<IslNetDevice> ()
|
||||
.AddAttribute ("Mtu", "The MAC-level Maximum Transmission Unit",
|
||||
UintegerValue (DEFAULT_MTU),
|
||||
MakeUintegerAccessor (&IslNetDevice::SetMtu,
|
||||
&IslNetDevice::GetMtu),
|
||||
MakeUintegerChecker<uint16_t> ())
|
||||
.AddAttribute ("Address",
|
||||
"The MAC address of this device.",
|
||||
Mac48AddressValue (Mac48Address ("ff:ff:ff:ff:ff:ff")),
|
||||
MakeMac48AddressAccessor (&IslNetDevice::m_address),
|
||||
MakeMac48AddressChecker ())
|
||||
.AddAttribute ("DataRate",
|
||||
"The default data rate for point to point links",
|
||||
DataRateValue (DataRate ("32768b/s")),
|
||||
MakeDataRateAccessor (&IslNetDevice::m_bps),
|
||||
MakeDataRateChecker ())
|
||||
.AddAttribute ("ReceiveErrorModel",
|
||||
"The receiver error model used to simulate packet loss",
|
||||
PointerValue (),
|
||||
MakePointerAccessor (&IslNetDevice::m_receiveErrorModel),
|
||||
MakePointerChecker<ErrorModel> ())
|
||||
.AddAttribute ("InterframeGap",
|
||||
"The time to wait between packet (frame) transmissions",
|
||||
TimeValue (Seconds (0.0)),
|
||||
MakeTimeAccessor (&IslNetDevice::m_tInterframeGap),
|
||||
MakeTimeChecker ())
|
||||
|
||||
//
|
||||
// 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 (&IslNetDevice::m_queue),
|
||||
MakePointerChecker<Queue<Packet> > ())
|
||||
.AddAttribute ("MobilityModel", "The mobility model of the device",
|
||||
PointerValue (),
|
||||
MakePointerAccessor (&IslNetDevice::SetMobilityModel,
|
||||
&IslNetDevice::GetMobilityModel),
|
||||
MakePointerChecker<MobilityModel> ())
|
||||
//
|
||||
// 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 (&IslNetDevice::m_macTxTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
.AddTraceSource ("MacTxDrop",
|
||||
"Trace source indicating a packet has been dropped "
|
||||
"by the device before transmission",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_macTxDropTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
.AddTraceSource ("MacPromiscRx",
|
||||
"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. "
|
||||
"This is a promiscuous trace,",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_macPromiscRxTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
.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. "
|
||||
"This is a non-promiscuous trace,",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_macRxTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
#if 0
|
||||
// Not currently implemented for this device
|
||||
.AddTraceSource ("MacRxDrop",
|
||||
"Trace source indicating a packet was dropped "
|
||||
"before being forwarded up the stack",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_macRxDropTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
#endif
|
||||
//
|
||||
// Trace sources at the "bottom" of the net device, where packets transition
|
||||
// to/from the channel.
|
||||
//
|
||||
.AddTraceSource ("PhyTxBegin",
|
||||
"Trace source indicating a packet has begun "
|
||||
"transmitting over the channel",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_phyTxBeginTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
.AddTraceSource ("PhyTxEnd",
|
||||
"Trace source indicating a packet has been "
|
||||
"completely transmitted over the channel",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_phyTxEndTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
.AddTraceSource ("PhyTxDrop",
|
||||
"Trace source indicating a packet has been "
|
||||
"dropped by the device during transmission",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_phyTxDropTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
#if 0
|
||||
// Not currently implemented for this device
|
||||
.AddTraceSource ("PhyRxBegin",
|
||||
"Trace source indicating a packet has begun "
|
||||
"being received by the device",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_phyRxBeginTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
#endif
|
||||
.AddTraceSource ("PhyRxEnd",
|
||||
"Trace source indicating a packet has been "
|
||||
"completely received by the device",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_phyRxEndTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
.AddTraceSource ("PhyRxDrop",
|
||||
"Trace source indicating a packet has been "
|
||||
"dropped by the device during reception",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_phyRxDropTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
|
||||
//
|
||||
// Trace sources designed to simulate a packet sniffer facility (tcpdump).
|
||||
// Note that there is really no difference between promiscuous and
|
||||
// non-promiscuous traces in a point-to-point link.
|
||||
//
|
||||
.AddTraceSource ("Sniffer",
|
||||
"Trace source simulating a non-promiscuous packet sniffer "
|
||||
"attached to the device",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_snifferTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
.AddTraceSource ("PromiscSniffer",
|
||||
"Trace source simulating a promiscuous packet sniffer "
|
||||
"attached to the device",
|
||||
MakeTraceSourceAccessor (&IslNetDevice::m_promiscSnifferTrace),
|
||||
"ns3::Packet::TracedCallback")
|
||||
;
|
||||
return tid;
|
||||
}
|
||||
|
||||
IslNetDevice::IslNetDevice ()
|
||||
:
|
||||
m_txMachineState (READY),
|
||||
m_channel (0),
|
||||
m_linkUp (false),
|
||||
m_currentPkt (0)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
}
|
||||
|
||||
IslNetDevice::~IslNetDevice ()
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::AddHeader (Ptr<Packet> p, uint16_t protocolNumber)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << p << protocolNumber);
|
||||
PppHeader ppp;
|
||||
ppp.SetProtocol (EtherToPpp (protocolNumber));
|
||||
p->AddHeader (ppp);
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::ProcessHeader (Ptr<Packet> p, uint16_t& param)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << p << param);
|
||||
PppHeader ppp;
|
||||
p->RemoveHeader (ppp);
|
||||
param = PppToEther (ppp.GetProtocol ());
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::DoInitialize (void)
|
||||
{
|
||||
if (m_queueInterface)
|
||||
{
|
||||
NS_ASSERT_MSG (m_queue != 0, "A Queue object has not been attached to the device");
|
||||
|
||||
// connect the traced callbacks of m_queue to the static methods provided by
|
||||
// the NetDeviceQueue class to support flow control and dynamic queue limits.
|
||||
// This could not be done in NotifyNewAggregate because at that time we are
|
||||
// not guaranteed that a queue has been attached to the netdevice
|
||||
m_queueInterface->GetTxQueue (0)->ConnectQueueTraces (m_queue);
|
||||
}
|
||||
|
||||
NetDevice::DoInitialize ();
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::NotifyNewAggregate (void)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
if (m_queueInterface == 0)
|
||||
{
|
||||
Ptr<NetDeviceQueueInterface> ndqi = this->GetObject<NetDeviceQueueInterface> ();
|
||||
//verify that it's a valid netdevice queue interface and that
|
||||
//the netdevice queue interface was not set before
|
||||
if (ndqi != 0)
|
||||
{
|
||||
m_queueInterface = ndqi;
|
||||
}
|
||||
}
|
||||
NetDevice::NotifyNewAggregate ();
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::DoDispose ()
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_node = 0;
|
||||
m_channel = 0;
|
||||
m_receiveErrorModel = 0;
|
||||
m_currentPkt = 0;
|
||||
m_queue = 0;
|
||||
m_queueInterface = 0;
|
||||
NetDevice::DoDispose ();
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetDataRate (DataRate bps)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_bps = bps;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetInterframeGap (Time t)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << t.GetSeconds ());
|
||||
m_tInterframeGap = t;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::TransmitStart (Ptr<Packet> p, const Address &dest)
|
||||
{
|
||||
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_currentPkt = p;
|
||||
m_phyTxBeginTrace (m_currentPkt);
|
||||
|
||||
Time txTime = m_bps.CalculateBytesTxTime (p->GetSize ());
|
||||
Time txCompleteTime = txTime + m_tInterframeGap;
|
||||
|
||||
NS_LOG_LOGIC ("Schedule TransmitCompleteEvent in " << txCompleteTime.GetSeconds () << "sec");
|
||||
Simulator::Schedule (txCompleteTime, &IslNetDevice::TransmitComplete, this, dest);
|
||||
|
||||
bool result = m_channel->TransmitStart (p, m_channelDevId, dest, txTime);
|
||||
if (result == false)
|
||||
{
|
||||
m_phyTxDropTrace (p);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::TransmitComplete (const Address &dest)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
|
||||
//
|
||||
// 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, "IslNetDevice::TransmitComplete(): m_currentPkt zero");
|
||||
|
||||
m_phyTxEndTrace (m_currentPkt);
|
||||
m_currentPkt = 0;
|
||||
|
||||
Ptr<Packet> p = m_queue->Dequeue ();
|
||||
if (p == 0)
|
||||
{
|
||||
NS_LOG_LOGIC ("No pending packets in device queue after tx complete");
|
||||
return;
|
||||
}
|
||||
|
||||
//
|
||||
// Got another packet off of the queue, so start the transmit process again.
|
||||
//
|
||||
m_snifferTrace (p);
|
||||
m_promiscSnifferTrace (p);
|
||||
TransmitStart (p, dest);
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::Attach (Ptr<IslChannel> ch)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << &ch);
|
||||
|
||||
m_channel = ch;
|
||||
|
||||
m_channelDevId = 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;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetQueue (Ptr<Queue<Packet> > q)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << q);
|
||||
m_queue = q;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetReceiveErrorModel (Ptr<ErrorModel> em)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << em);
|
||||
m_receiveErrorModel = em;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::Receive (Ptr<Packet> packet)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << packet);
|
||||
uint16_t protocol = 0;
|
||||
|
||||
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 because it is so simple, but this is not usually the case in
|
||||
// more complicated devices.
|
||||
//
|
||||
m_snifferTrace (packet);
|
||||
m_promiscSnifferTrace (packet);
|
||||
m_phyRxEndTrace (packet);
|
||||
|
||||
//
|
||||
// Trace sinks will expect complete packets, not packets without some of the
|
||||
// headers.
|
||||
//
|
||||
Ptr<Packet> originalPacket = packet->Copy ();
|
||||
|
||||
//
|
||||
// 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 ())
|
||||
{
|
||||
m_macPromiscRxTrace (originalPacket);
|
||||
m_promiscCallback (this, packet, protocol, GetRemote (), GetAddress (), NetDevice::PACKET_HOST);
|
||||
}
|
||||
|
||||
m_macRxTrace (originalPacket);
|
||||
m_rxCallback (this, packet, protocol, GetRemote ());
|
||||
}
|
||||
}
|
||||
|
||||
Ptr<Queue<Packet> >
|
||||
IslNetDevice::GetQueue (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return m_queue;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::NotifyLinkUp (void)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_linkUp = true;
|
||||
m_linkChangeCallbacks ();
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::NotifyLinkDown (void)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_linkUp = false;
|
||||
m_linkChangeCallbacks ();
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetIfIndex (const uint32_t index)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_ifIndex = index;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
IslNetDevice::GetIfIndex (void) const
|
||||
{
|
||||
return m_ifIndex;
|
||||
}
|
||||
|
||||
Ptr<Channel>
|
||||
IslNetDevice::GetChannel (void) const
|
||||
{
|
||||
return m_channel;
|
||||
}
|
||||
|
||||
//
|
||||
// This is a point-to-point device, so we really don't need any kind of address
|
||||
// information. However, the base class NetDevice wants us to define the
|
||||
// methods to get and set the address. Rather than be rude and assert, we let
|
||||
// clients get and set the address, but simply ignore them.
|
||||
|
||||
void
|
||||
IslNetDevice::SetAddress (Address address)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << address);
|
||||
m_address = Mac48Address::ConvertFrom (address);
|
||||
}
|
||||
|
||||
Address
|
||||
IslNetDevice::GetAddress (void) const
|
||||
{
|
||||
return m_address;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::IsLinkUp (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return m_linkUp;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::AddLinkChangeCallback (Callback<void> callback)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_linkChangeCallbacks.ConnectWithoutContext (callback);
|
||||
}
|
||||
|
||||
//
|
||||
// This is a point-to-point device, so every transmission is a broadcast to
|
||||
// all of the devices on the network.
|
||||
//
|
||||
bool
|
||||
IslNetDevice::IsBroadcast (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return true;
|
||||
}
|
||||
|
||||
//
|
||||
// We don't really need any addressing information since this is a
|
||||
// point-to-point device. The base class NetDevice wants us to return a
|
||||
// broadcast address, so we make up something reasonable.
|
||||
//
|
||||
Address
|
||||
IslNetDevice::GetBroadcast (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return Mac48Address ("ff:ff:ff:ff:ff:ff");
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::IsMulticast (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return true;
|
||||
}
|
||||
|
||||
Address
|
||||
IslNetDevice::GetMulticast (Ipv4Address multicastGroup) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return Mac48Address ("01:00:5e:00:00:00");
|
||||
}
|
||||
|
||||
Address
|
||||
IslNetDevice::GetMulticast (Ipv6Address addr) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this << addr);
|
||||
return Mac48Address ("33:33:00:00:00:00");
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::IsIsl (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::IsBridge (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::Send (
|
||||
Ptr<Packet> packet,
|
||||
const Address &dest,
|
||||
uint16_t protocolNumber)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << packet << dest << protocolNumber);
|
||||
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);
|
||||
|
||||
//
|
||||
// We should enqueue and dequeue the packet to hit the tracing hooks.
|
||||
//
|
||||
if (m_queue->Enqueue (packet))
|
||||
{
|
||||
//
|
||||
// If the channel is ready for transition we send the packet right now
|
||||
//
|
||||
if (m_txMachineState == READY)
|
||||
{
|
||||
packet = m_queue->Dequeue ();
|
||||
m_snifferTrace (packet);
|
||||
m_promiscSnifferTrace (packet);
|
||||
bool ret = TransmitStart (packet, dest);
|
||||
return ret;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Enqueue may fail (overflow)
|
||||
|
||||
m_macTxDropTrace (packet);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::SendFrom (Ptr<Packet> packet,
|
||||
const Address &source,
|
||||
const Address &dest,
|
||||
uint16_t protocolNumber)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << packet << source << dest << protocolNumber);
|
||||
return false;
|
||||
}
|
||||
|
||||
Ptr<Node>
|
||||
IslNetDevice::GetNode (void) const
|
||||
{
|
||||
return m_node;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetNode (Ptr<Node> node)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_node = node;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::NeedsArp (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetReceiveCallback (NetDevice::ReceiveCallback cb)
|
||||
{
|
||||
m_rxCallback = cb;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetPromiscReceiveCallback (NetDevice::PromiscReceiveCallback cb)
|
||||
{
|
||||
m_promiscCallback = cb;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::SupportsSendFrom (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return false;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::DoMpiReceive (Ptr<Packet> p)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << p);
|
||||
Receive (p);
|
||||
}
|
||||
|
||||
Address
|
||||
IslNetDevice::GetRemote (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
NS_ASSERT (m_channel->GetNDevices () == 2);
|
||||
for (std::size_t i = 0; i < m_channel->GetNDevices (); ++i)
|
||||
{
|
||||
Ptr<NetDevice> tmp = m_channel->GetDevice (i);
|
||||
if (tmp != this)
|
||||
{
|
||||
return tmp->GetAddress ();
|
||||
}
|
||||
}
|
||||
NS_ASSERT (false);
|
||||
// quiet compiler.
|
||||
return Address ();
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::SetMtu (uint16_t mtu)
|
||||
{
|
||||
NS_LOG_FUNCTION (this << mtu);
|
||||
m_mtu = mtu;
|
||||
return true;
|
||||
}
|
||||
|
||||
uint16_t
|
||||
IslNetDevice::GetMtu (void) const
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
return m_mtu;
|
||||
}
|
||||
|
||||
uint16_t
|
||||
IslNetDevice::PppToEther (uint16_t proto)
|
||||
{
|
||||
NS_LOG_FUNCTION_NOARGS();
|
||||
switch(proto)
|
||||
{
|
||||
case 0x0021: return 0x0800; //IPv4
|
||||
case 0x0057: return 0x86DD; //IPv6
|
||||
case 2054: return 0x0806; //ARP
|
||||
default: NS_ASSERT_MSG (false, "PPP Protocol number not defined!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint16_t
|
||||
IslNetDevice::EtherToPpp (uint16_t proto)
|
||||
{
|
||||
NS_LOG_FUNCTION_NOARGS();
|
||||
switch(proto)
|
||||
{
|
||||
case 0x0800: return 0x0021; //IPv4
|
||||
case 0x86DD: return 0x0057; //IPv6
|
||||
case 0x0806: return 2054; //ARP
|
||||
default: NS_ASSERT_MSG (false, "PPP Protocol number not defined!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
Ptr<MobilityModel>
|
||||
IslNetDevice::GetMobilityModel (void) const
|
||||
{
|
||||
return m_mobilityModel;
|
||||
}
|
||||
|
||||
void
|
||||
IslNetDevice::SetMobilityModel (Ptr<MobilityModel> model)
|
||||
{
|
||||
NS_LOG_FUNCTION (this);
|
||||
m_mobilityModel = model;
|
||||
}
|
||||
|
||||
bool
|
||||
IslNetDevice::IsPointToPoint() const
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace ns3
|
||||
Loading…
Add table
Add a link
Reference in a new issue