dadada/ns-3-leo
dadada/ns-3-leo
1
0
Fork 0
mirror of https://gitlab.ibr.cs.tu-bs.de/tschuber/ns-3-leo.git synced 2025-06-08 01:53:58 +02:00
Code Issues Releases Wiki Activity

init

Browse source
This commit is contained in:
Tim Schubert 2020-06-20 16:14:00 +02:00
commit 13e4bf1aa7
21 changed files with 2601 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored Normal file
View file

@ -0,0 +1 @@
*.swp

98
doc/leo.rst Normal file
View file

@ -0,0 +1,98 @@
Example Module Documentation
----------------------------
.. include:: replace.txt
.. highlight:: cpp
.. heading hierarchy:
------------- Chapter
************* Section (#.#)
============= Subsection (#.#.#)
############# Paragraph (no number)
This is a suggested outline for adding new module documentation to |ns3|.
See ``src/click/doc/click.rst`` for an example.
The introductory paragraph is for describing what this code is trying to
model.
For consistency (italicized formatting), please use |ns3| to refer to
ns-3 in the documentation (and likewise, |ns2| for ns-2). These macros
are defined in the file ``replace.txt``.
Model Description
*****************
The source code for the new module lives in the directory ``src/leo``.
Add here a basic description of what is being modeled.
Design
======
Briefly describe the software design of the model and how it fits into
the existing ns-3 architecture.
Scope and Limitations
=====================
What can the model do? What can it not do? Please use this section to
describe the scope and limitations of the model.
References
==========
Add academic citations here, such as if you published a paper on this
model, or if readers should read a particular specification or other work.
Usage
*****
This section is principally concerned with the usage of your model, using
the public API. Focus first on most common usage patterns, then go
into more advanced topics.
Building New Module
===================
Include this subsection only if there are special build instructions or
platform limitations.
Helpers
=======
What helper API will users typically use? Describe it here.
Attributes
==========
What classes hold attributes, and what are the key ones worth mentioning?
Output
======
What kind of data does the model generate? What are the key trace
sources? What kind of logging output can be enabled?
Advanced Usage
==============
Go into further details (such as using the API outside of the helpers)
in additional sections, as needed.
Examples
========
What examples using this new code are available? Describe them here.
Troubleshooting
===============
Add any tips for avoiding pitfalls, etc.
Validation
**********
Describe how the model has been tested/validated. What tests run in the
test suite? How much API and code is covered by the tests? Again,
references to outside published work may help here.

66
examples/isl-example.cc Normal file
View file

@ -0,0 +1,66 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/applications-module.h"
#include "ns3/node-container.h"
#include "ns3/leo-module.h"
using namespace ns3;
NS_LOG_COMPONENT_DEFINE ("IslExample");
int
main (int argc, char *argv[])
{
CommandLine cmd;
cmd.Parse (argc, argv);
Time::SetResolution (Time::NS);
LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);
LogComponentEnable ("UdpClient", LOG_LEVEL_DEBUG);
LogComponentEnable ("IslChannel", LOG_LEVEL_LOGIC);
NodeContainer nodes;
nodes.Create (2);
IslHelper isl;
isl.SetDeviceAttribute ("DataRate", StringValue ("5Gbps"));
isl.SetChannelAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
isl.SetChannelAttribute ("PropagationLoss", StringValue ("ns3::IslPropagationLossModel"));
isl.SetDeviceAttribute ("MobilityModel", StringValue ("ns3::LeoMobilityModel"));
NetDeviceContainer devices;
devices = isl.Install (nodes);
InternetStackHelper stack;
stack.Install (nodes);
Ipv6AddressHelper address;
Ipv6InterfaceContainer interfaces = address.Assign (devices);
UdpEchoServerHelper echoServer (9);
ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
Address destAddress = interfaces.GetAddress (1, 0);
UdpEchoClientHelper echoClient (destAddress, 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (10));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));
Simulator::Run ();
Simulator::Destroy ();
return 0;
}

26
examples/leo-example.cc Normal file
View file

@ -0,0 +1,26 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "ns3/core-module.h"
#include "ns3/leo-helper.h"
using namespace ns3;
int
main (int argc, char *argv[])
{
bool verbose = true;
CommandLine cmd;
cmd.AddValue ("verbose", "Tell application to log if true", verbose);
cmd.Parse (argc,argv);
/* ... */
Simulator::Run ();
Simulator::Destroy ();
return 0;
}

9
examples/wscript Normal file
View file

@ -0,0 +1,9 @@
# -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
def build(bld):
obj = bld.create_ns3_program('leo-example', ['leo'])
obj.source = 'leo-example.cc'
obj = bld.create_ns3_program('isl-example', ['leo'])
obj.source = 'isl-example.cc'

258
helper/isl-helper.cc Normal file
View file

@ -0,0 +1,258 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2008 INRIA
*
* 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
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#include "ns3/abort.h"
#include "ns3/log.h"
#include "ns3/simulator.h"
#include "ns3/point-to-point-net-device.h"
#include "ns3/point-to-point-channel.h"
#include "ns3/point-to-point-remote-channel.h"
#include "ns3/queue.h"
#include "ns3/config.h"
#include "ns3/packet.h"
#include "ns3/names.h"
#include "ns3/trace-helper.h"
#include "../model/isl-net-device.h"
#include "../model/isl-channel.h"
#include "isl-helper.h"
namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("IslHelper");
IslHelper::IslHelper ()
{
m_queueFactory.SetTypeId ("ns3::DropTailQueue<Packet>");
m_deviceFactory.SetTypeId ("ns3::IslNetDevice");
m_channelFactory.SetTypeId ("ns3::IslChannel");
}
void
IslHelper::SetQueue (std::string type,
std::string n1, const AttributeValue &v1,
std::string n2, const AttributeValue &v2,
std::string n3, const AttributeValue &v3,
std::string n4, const AttributeValue &v4)
{
QueueBase::AppendItemTypeIfNotPresent (type, "Packet");
m_queueFactory.SetTypeId (type);
m_queueFactory.Set (n1, v1);
m_queueFactory.Set (n2, v2);
m_queueFactory.Set (n3, v3);
m_queueFactory.Set (n4, v4);
}
void
IslHelper::SetDeviceAttribute (std::string n1, const AttributeValue &v1)
{
m_deviceFactory.Set (n1, v1);
}
void
IslHelper::SetChannelAttribute (std::string n1, const AttributeValue &v1)
{
m_channelFactory.Set (n1, v1);
}
void
IslHelper::EnablePcapInternal (std::string prefix, Ptr<NetDevice> nd, bool promiscuous, bool explicitFilename)
{
//
// All of the Pcap enable functions vector through here including the ones
// that are wandering through all of devices on perhaps all of the nodes in
// the system. We can only deal with devices of type IslNetDevice.
//
Ptr<IslNetDevice> device = nd->GetObject<IslNetDevice> ();
if (device == 0)
{
NS_LOG_INFO ("IslHelper::EnablePcapInternal(): Device " << device << " not of type ns3::IslNetDevice");
return;
}
PcapHelper pcapHelper;
std::string filename;
if (explicitFilename)
{
filename = prefix;
}
else
{
filename = pcapHelper.GetFilenameFromDevice (prefix, device);
}
Ptr<PcapFileWrapper> file = pcapHelper.CreateFile (filename, std::ios::out,
PcapHelper::DLT_PPP);
pcapHelper.HookDefaultSink<IslNetDevice> (device, "PromiscSniffer", file);
}
void
IslHelper::EnableAsciiInternal (
Ptr<OutputStreamWrapper> stream,
std::string prefix,
Ptr<NetDevice> nd,
bool explicitFilename)
{
//
// All of the ascii enable functions vector through here including the ones
// that are wandering through all of devices on perhaps all of the nodes in
// the system. We can only deal with devices of type IslNetDevice.
//
Ptr<IslNetDevice> device = nd->GetObject<IslNetDevice> ();
if (device == 0)
{
NS_LOG_INFO ("IslHelper::EnableAsciiInternal(): Device " << device <<
" not of type ns3::IslNetDevice");
return;
}
//
// Our default trace sinks are going to use packet printing, so we have to
// make sure that is turned on.
//
Packet::EnablePrinting ();
//
// If we are not provided an OutputStreamWrapper, we are expected to create
// one using the usual trace filename conventions and do a Hook*WithoutContext
// since there will be one file per context and therefore the context would
// be redundant.
//
if (stream == 0)
{
//
// Set up an output stream object to deal with private ofstream copy
// constructor and lifetime issues. Let the helper decide the actual
// name of the file given the prefix.
//
AsciiTraceHelper asciiTraceHelper;
std::string filename;
if (explicitFilename)
{
filename = prefix;
}
else
{
filename = asciiTraceHelper.GetFilenameFromDevice (prefix, device);
}
Ptr<OutputStreamWrapper> theStream = asciiTraceHelper.CreateFileStream (filename);
//
// The MacRx trace source provides our "r" event.
//
asciiTraceHelper.HookDefaultReceiveSinkWithoutContext<IslNetDevice> (device, "MacRx", theStream);
//
// The "+", '-', and 'd' events are driven by trace sources actually in the
// transmit queue.
//
Ptr<Queue<Packet> > queue = device->GetQueue ();
asciiTraceHelper.HookDefaultEnqueueSinkWithoutContext<Queue<Packet> > (queue, "Enqueue", theStream);
asciiTraceHelper.HookDefaultDropSinkWithoutContext<Queue<Packet> > (queue, "Drop", theStream);
asciiTraceHelper.HookDefaultDequeueSinkWithoutContext<Queue<Packet> > (queue, "Dequeue", theStream);
// PhyRxDrop trace source for "d" event
asciiTraceHelper.HookDefaultDropSinkWithoutContext<IslNetDevice> (device, "PhyRxDrop", theStream);
return;
}
//
// If we are provided an OutputStreamWrapper, we are expected to use it, and
// to providd a context. We are free to come up with our own context if we
// want, and use the AsciiTraceHelper Hook*WithContext functions, but for
// compatibility and simplicity, we just use Config::Connect and let it deal
// with the context.
//
// Note that we are going to use the default trace sinks provided by the
// ascii trace helper. There is actually no AsciiTraceHelper in sight here,
// but the default trace sinks are actually publicly available static
// functions that are always there waiting for just such a case.
//
uint32_t nodeid = nd->GetNode ()->GetId ();
uint32_t deviceid = nd->GetIfIndex ();
std::ostringstream oss;
oss << "/NodeList/" << nd->GetNode ()->GetId () << "/DeviceList/" << deviceid << "/$ns3::IslNetDevice/MacRx";
Config::Connect (oss.str (), MakeBoundCallback (&AsciiTraceHelper::DefaultReceiveSinkWithContext, stream));
oss.str ("");
oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::IslNetDevice/TxQueue/Enqueue";
Config::Connect (oss.str (), MakeBoundCallback (&AsciiTraceHelper::DefaultEnqueueSinkWithContext, stream));
oss.str ("");
oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::IslNetDevice/TxQueue/Dequeue";
Config::Connect (oss.str (), MakeBoundCallback (&AsciiTraceHelper::DefaultDequeueSinkWithContext, stream));
oss.str ("");
oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::IslNetDevice/TxQueue/Drop";
Config::Connect (oss.str (), MakeBoundCallback (&AsciiTraceHelper::DefaultDropSinkWithContext, stream));
oss.str ("");
oss << "/NodeList/" << nodeid << "/DeviceList/" << deviceid << "/$ns3::IslNetDevice/PhyRxDrop";
Config::Connect (oss.str (), MakeBoundCallback (&AsciiTraceHelper::DefaultDropSinkWithContext, stream));
}
NetDeviceContainer
IslHelper::Install (NodeContainer c)
{
std::vector<Ptr<Node> > nodes = std::vector<Ptr<Node> >(c.Begin(), c.End());
return Install (nodes);
}
NetDeviceContainer
IslHelper::Install (std::vector<Ptr<Node> > &nodes)
{
Ptr<IslChannel> channel = m_channelFactory.Create<IslChannel> ();
NetDeviceContainer container;
for (Ptr<Node> node: nodes)
{
Ptr<IslNetDevice> dev = m_deviceFactory.Create<IslNetDevice> ();
dev->SetAddress (Mac48Address::Allocate ());
node->AddDevice (dev);
Ptr<Queue<Packet> > queue = m_queueFactory.Create<Queue<Packet> > ();
dev->SetQueue (queue);
dev->Attach (channel);
container.Add (dev);
}
return container;
}
NetDeviceContainer
IslHelper::Install (std::vector<std::string> &names)
{
std::vector<Ptr<Node> > nodes;
for (std::string name : names)
{
Ptr<Node> node = Names::Find<Node>(name);
nodes.push_back (node);
}
return Install (nodes);
}
} // namespace ns3

169
helper/isl-helper.h Normal file
View file

@ -0,0 +1,169 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2008 INRIA
*
* 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
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
*/
#ifndef ISL_HELPER_H
#define ISL_HELPER_H
#include <string>
#include <ns3/object-factory.h>
#include <ns3/net-device-container.h>
#include <ns3/node-container.h>
#include <ns3/trace-helper.h>
namespace ns3 {
class NetDevice;
class Node;
/**
* \brief Build a set of IslNetDevice objects
*
* Normally we eschew multiple inheritance, however, the classes
* PcapUserHelperForDevice and AsciiTraceUserHelperForDevice are
* "mixins".
*/
class IslHelper : public PcapHelperForDevice,
public AsciiTraceHelperForDevice
{
public:
/**
* Create a IslHelper to make life easier when creating ISL networks.
*/
IslHelper ();
virtual ~IslHelper () {}
/**
* Each point to point net device must have a queue to pass packets through.
* This method allows one to set the type of the queue that is automatically
* created when the device is created and attached to a node.
*
* \param type the type of queue
* \param n1 the name of the attribute to set on the queue
* \param v1 the value of the attribute to set on the queue
* \param n2 the name of the attribute to set on the queue
* \param v2 the value of the attribute to set on the queue
* \param n3 the name of the attribute to set on the queue
* \param v3 the value of the attribute to set on the queue
* \param n4 the name of the attribute to set on the queue
* \param v4 the value of the attribute to set on the queue
*
* Set the type of queue to create and associated to each
* IslNetDevice created through IslHelper::Install.
*/
void SetQueue (std::string type,
std::string n1 = "", const AttributeValue &v1 = EmptyAttributeValue (),
std::string n2 = "", const AttributeValue &v2 = EmptyAttributeValue (),
std::string n3 = "", const AttributeValue &v3 = EmptyAttributeValue (),
std::string n4 = "", const AttributeValue &v4 = EmptyAttributeValue ());
/**
* Set an attribute value to be propagated to each NetDevice created by the
* helper.
*
* \param name the name of the attribute to set
* \param value the value of the attribute to set
*
* Set these attributes on each ns3::IslNetDevice created
* by IslHelper::Install
*/
void SetDeviceAttribute (std::string name, const AttributeValue &value);
/**
* Set an attribute value to be propagated to each Channel created by the
* helper.
*
* \param name the name of the attribute to set
* \param value the value of the attribute to set
*
* Set these attribute on each ns3::IslChannel created
* by IslHelper::Install
*/
void SetChannelAttribute (std::string name, const AttributeValue &value);
/**
* \param c a set of nodes
* \return a NetDeviceContainer for nodes
*
* This method creates a ns3::IslChannel with the
* attributes configured by IslHelper::SetChannelAttribute,
* then, for each node in the input container, we create a
* ns3::IslNetDevice with the requested attributes,
* a queue for this ns3::NetDevice, and associate the resulting
* ns3::NetDevice with the ns3::Node and ns3::IslChannel.
*/
NetDeviceContainer Install (NodeContainer c);
/**
* \param nodes Nodes
* \return a NetDeviceContainer for nodes
*
* Saves you from having to construct a temporary NodeContainer.
*/
NetDeviceContainer Install (std::vector<Ptr<Node> > &nodes);
/**
* \param nodes Names of the nodes
* \return a NetDeviceContainer for nodes
*
* Saves you from having to construct a temporary NodeContainer.
*/
NetDeviceContainer Install (std::vector<std::string> &nodes);
private:
/**
* \brief Enable pcap output the indicated net device.
*
* NetDevice-specific implementation mechanism for hooking the trace and
* writing to the trace file.
*
* \param prefix Filename prefix to use for pcap files.
* \param nd Net device for which you want to enable tracing.
* \param promiscuous If true capture all possible packets available at the device.
* \param explicitFilename Treat the prefix as an explicit filename if true
*/
virtual void EnablePcapInternal (std::string prefix, Ptr<NetDevice> nd, bool promiscuous, bool explicitFilename);
/**
* \brief Enable ascii trace output on the indicated net device.
*
* NetDevice-specific implementation mechanism for hooking the trace and
* writing to the trace file.
*
* \param stream The output stream object to use when logging ascii traces.
* \param prefix Filename prefix to use for ascii trace files.
* \param nd Net device for which you want to enable tracing.
* \param explicitFilename Treat the prefix as an explicit filename if true
*/
virtual void EnableAsciiInternal (
Ptr<OutputStreamWrapper> stream,
std::string prefix,
Ptr<NetDevice> nd,
bool explicitFilename);
ObjectFactory m_queueFactory; //!< Queue Factory
ObjectFactory m_channelFactory; //!< Channel Factory
ObjectFactory m_deviceFactory; //!< Device Factory
};
} // namespace ns3
#endif /* ISL_HELPER_H */

11
helper/leo-helper.cc Normal file
View file

@ -0,0 +1,11 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "leo-helper.h"
namespace ns3 {
/* ... */
}

14
helper/leo-helper.h Normal file
View file

@ -0,0 +1,14 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef LEO_HELPER_H
#define LEO_HELPER_H
#include "ns3/leo.h"
namespace ns3 {
/* ... */
}
#endif /* LEO_HELPER_H */

200
model/isl-channel.cc Normal file
View file

@ -0,0 +1,200 @@
/* -*- 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/trace-source-accessor.h>
#include <ns3/packet.h>
#include <ns3/simulator.h>
#include <ns3/log.h>
#include <ns3/pointer.h>
#include "isl-channel.h"
namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("IslChannel");
NS_OBJECT_ENSURE_REGISTERED (IslChannel);
TypeId
IslChannel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::IslChannel")
.SetParent<Channel> ()
.SetGroupName ("Leo")
.AddConstructor<IslChannel> ()
.AddAttribute ("PropagationDelay",
"A propagation delay model for the channel.",
PointerValue (),
MakePointerAccessor (&IslChannel::m_propagationDelay),
MakePointerChecker<PropagationDelayModel> ())
.AddAttribute ("PropagationLoss",
"A propagation loss model for the channel.",
PointerValue (),
MakePointerAccessor (&IslChannel::m_propagationLoss),
MakePointerChecker<PropagationLossModel> ())
.AddTraceSource ("TxRxIslChannel",
"Trace source indicating transmission of packet "
"from the IslChannel, used by the Animation "
"interface.",
MakeTraceSourceAccessor (&IslChannel::m_txrxIsl),
"ns3::IslChannel::TxRxAnimationCallback")
;
return tid;
}
//
// By default, you get a channel that
// has an "infitely" fast transmission speed and zero processing delay.
IslChannel::IslChannel() : Channel (), m_link (0)
{
NS_LOG_FUNCTION_NOARGS ();
}
IslChannel::~IslChannel()
{
}
bool
IslChannel::Detach (uint32_t deviceId)
{
NS_LOG_FUNCTION (this << deviceId);
if (deviceId < m_link.size ())
{
if (!m_link[deviceId]->IsLinkUp ())
{
NS_LOG_WARN ("IslChannel::Detach(): Device is already detached (" << deviceId << ")");
return false;
}
m_link[deviceId]->NotifyLinkDown ();
}
else
{
return false;
}
return true;
}
int32_t
IslChannel::Attach (Ptr<IslNetDevice> device)
{
NS_LOG_FUNCTION (this << device);
NS_ASSERT (device != 0);
m_link.push_back(device);
return m_link.size() - 1;
}
std::size_t
IslChannel::GetNDevices (void) const
{
NS_LOG_FUNCTION_NOARGS ();
return m_link.size ();
}
Ptr<NetDevice>
IslChannel::GetDevice (std::size_t i) const
{
NS_LOG_FUNCTION_NOARGS ();
return m_link[i];
}
bool IslChannel::Deliver (
Ptr<const Packet> p,
Ptr<IslNetDevice> src,
Ptr<IslNetDevice> dst,
Time txTime)
{
Time delay = GetDelay (src, dst, txTime);
/* Check if there is LOS between the source and destination */
if (m_propagationLoss->CalcRxPower(1, src->GetMobilityModel(), dst->GetMobilityModel()) > 0)
{
Simulator::ScheduleWithContext (dst->GetNode ()->GetId (),
delay,
&IslNetDevice::Receive,
dst,
p->Copy ());
// Call the tx anim callback on the net device
m_txrxIsl (p, src, dst, txTime, delay);
return true;
}
else
{
NS_LOG_LOGIC (dst << " unreachable from " << src);
return false;
}
}
bool
IslChannel::TransmitStart (
Ptr<const Packet> p,
uint32_t srcId,
Address destAddr,
Time txTime)
{
NS_LOG_FUNCTION (destAddr << this << p << srcId);
NS_LOG_LOGIC ("UID is " << p->GetUid () << ")");
Ptr<IslNetDevice> src = m_link[srcId];
Ptr<IslNetDevice> dst = GetDevice (destAddr);
if (dst == nullptr)
{
NS_LOG_LOGIC ("destination address " << destAddr << " unknown on channel");
for (uint32_t i = 0; i < m_link.size (); i++)
{
Deliver (p, src, m_link[i], txTime);
}
return true;
}
else
{
return Deliver (p, src, dst, txTime);
}
}
Time
IslChannel::GetDelay (Ptr<const IslNetDevice> src, Ptr<const IslNetDevice> dst, Time txTime) const
{
NS_LOG_DEBUG ("Get delay from " << src << " to " << dst);
Ptr<MobilityModel> modSrc = src->GetMobilityModel ();
Ptr<MobilityModel> modDst = dst->GetMobilityModel ();
Time propagationDelay = m_propagationDelay->GetDelay (modSrc, modDst);
return txTime + propagationDelay;
}
// TODO optimize
Ptr<IslNetDevice>
IslChannel::GetDevice (Address &addr) const
{
for (Ptr<IslNetDevice> dev : m_link)
{
if (dev->GetAddress () == addr)
{
return dev;
}
}
return 0;
}
} // namespace ns3

107
model/isl-channel.h Normal file
View file

@ -0,0 +1,107 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* 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
*/
#ifndef ISL_CHANNEL_H
#define ISL_CHANNEL_H
#include <string>
#include <stdint.h>
#include "ns3/object.h"
#include "ns3/ptr.h"
#include "ns3/channel.h"
#include "ns3/mobility-model.h"
#include "ns3/net-device.h"
#include "ns3/time-data-calculators.h"
#include "ns3/traced-callback.h"
#include "ns3/mobility-module.h"
#include "ns3/propagation-delay-model.h"
#include "ns3/propagation-loss-model.h"
#include "isl-net-device.h"
namespace ns3 {
class IslNetDevice;
/**
* \ingroup network
* \defgroup channel Channel
*/
/**
* \ingroup channel
* \brief Simplified inter-satellite channel
*
* A perfect channel with varariable delay (time-of-flight).
*
*/
class IslChannel : public Channel
{
public:
static TypeId GetTypeId (void);
IslChannel ();
virtual ~IslChannel ();
/**
* \brief Attach a device to the channel.
* \param device Device to attach to the channel
* \return Index of the device inside the devices list
*/
int32_t Attach (Ptr<IslNetDevice> device);
/**
* \brief Detach a given netdevice from this channel
* \param device pointer to the netdevice to detach from the channel
* \return true on success, false on failure
*/
bool Detach (uint32_t deviceId);
virtual std::size_t GetNDevices (void) const;
virtual Ptr<NetDevice> GetDevice (std::size_t i) const;
virtual bool TransmitStart (Ptr<const Packet> p, uint32_t devId, Address dst, Time txTime);
protected:
/**
* \brief Get the delay associated with this channel
* \returns Time delay
*/
Time GetDelay (Ptr<const IslNetDevice> first, Ptr<const IslNetDevice> second, Time txTime) const;
private:
Ptr<IslNetDevice> GetDevice (Address &addr) const;
TracedCallback<Ptr<const Packet>, // Packet being transmitted
Ptr<NetDevice>, // Transmitting NetDevice
Ptr<NetDevice>, // Receiving NetDevice
Time, // Amount of time to transmit the pkt
Time // Last bit receive time (relative to now)
> m_txrxIsl;
/**
* \brief Propagation delay model to be used with this channel
*/
Ptr<PropagationDelayModel> m_propagationDelay;
/**
* \brief Propagation loss model to be used with this channel
*/
Ptr<PropagationLossModel> m_propagationLoss;
std::vector<Ptr<IslNetDevice> > m_link;
bool Deliver (Ptr<const Packet> p, Ptr<IslNetDevice> src, Ptr<IslNetDevice> dst, Time txTime);
}; // class IslChannel
} // namespace ns3
#endif /* ISL_CHANNEL_H */

742
model/isl-net-device.cc Normal file
View 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

499
model/isl-net-device.h Normal file
View file

@ -0,0 +1,499 @@
/* -*- 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
*/
#ifndef ISL_NET_DEVICE_H
#define ISL_NET_DEVICE_H
#include <cstring>
#include "ns3/address.h"
#include "ns3/node.h"
#include "ns3/net-device.h"
#include "ns3/callback.h"
#include "ns3/packet.h"
#include "ns3/traced-callback.h"
#include "ns3/nstime.h"
#include "ns3/data-rate.h"
#include "ns3/ptr.h"
#include "ns3/mac48-address.h"
#include "ns3/mobility-model.h"
namespace ns3 {
template <typename Item> class Queue;
class NetDeviceQueueInterface;
class IslChannel;
class ErrorModel;
/**
* \defgroup point-to-point Point-To-Point Network Device
* This section documents the API of the ns-3 point-to-point module. For a
* functional description, please refer to the ns-3 manual here:
* http://www.nsnam.org/docs/models/html/point-to-point.html
*
* Be sure to read the manual BEFORE going down to the API.
*/
/**
* \ingroup point-to-point
* \class IslNetDevice
* \brief A Device for a Point to Point Network Link.
*
* This IslNetDevice class specializes the NetDevice abstract
* base class. Together with a IslChannel (and a peer
* IslNetDevice), the class models, with some level of
* abstraction, a generic point-to-point or serial link.
* Key parameters or objects that can be specified for this device
* include a queue, data rate, and interframe transmission gap (the
* propagation delay is set in the IslChannel).
*/
class IslNetDevice : public NetDevice
{
public:
/**
* \brief Get the TypeId
*
* \return The TypeId for this class
*/
static TypeId GetTypeId (void);
/**
* Construct a IslNetDevice
*
* This is the constructor for the IslNetDevice. It takes as a
* parameter a pointer to the Node to which this device is connected,
* as well as an optional DataRate object.
*/
IslNetDevice ();
/**
* Destroy a IslNetDevice
*
* This is the destructor for the IslNetDevice.
*/
virtual ~IslNetDevice ();
/**
* Set the Data Rate used for transmission of packets. The data rate is
* set in the Attach () method from the corresponding field in the channel
* to which the device is attached. It can be overridden using this method.
*
* \param bps the data rate at which this object operates
*/
void SetDataRate (DataRate bps);
/**
* Set the interframe gap used to separate packets. The interframe gap
* defines the minimum space required between packets sent by this device.
*
* \param t the interframe gap time
*/
void SetInterframeGap (Time t);
/**
* Attach the device to a channel.
*
* \param ch Ptr to the channel to which this object is being attached.
* \return true if the operation was successful (always true actually)
*/
bool Attach (Ptr<IslChannel> ch);
/**
* Attach a queue to the IslNetDevice.
*
* The IslNetDevice "owns" a queue that implements a queueing
* method such as DropTailQueue or RedQueue
*
* \param queue Ptr to the new queue.
*/
void SetQueue (Ptr<Queue<Packet> > queue);
/**
* Get a copy of the attached Queue.
*
* \returns Ptr to the queue.
*/
Ptr<Queue<Packet> > GetQueue (void) const;
/**
* Attach a receive ErrorModel to the IslNetDevice.
*
* The IslNetDevice may optionally include an ErrorModel in
* the packet receive chain.
*
* \param em Ptr to the ErrorModel.
*/
void SetReceiveErrorModel (Ptr<ErrorModel> em);
/**
* Receive a packet from a connected IslChannel.
*
* The IslNetDevice receives packets from its connected channel
* and forwards them up the protocol stack. This is the public method
* used by the channel to indicate that the last bit of a packet has
* arrived at the device.
*
* \param p Ptr to the received packet.
*/
void Receive (Ptr<Packet> p);
// The remaining methods are documented in ns3::NetDevice*
virtual void SetIfIndex (const uint32_t index);
virtual uint32_t GetIfIndex (void) const;
virtual Ptr<Channel> GetChannel (void) const;
virtual void SetAddress (Address address);
virtual Address GetAddress (void) const;
virtual bool SetMtu (const uint16_t mtu);
virtual uint16_t GetMtu (void) const;
virtual bool IsLinkUp (void) const;
virtual void AddLinkChangeCallback (Callback<void> callback);
virtual bool IsBroadcast (void) const;
virtual Address GetBroadcast (void) const;
virtual bool IsMulticast (void) const;
virtual Address GetMulticast (Ipv4Address multicastGroup) const;
virtual bool IsIsl (void) const;
virtual bool IsBridge (void) const;
virtual bool IsPointToPoint() const;
virtual bool Send (Ptr<Packet> packet, const Address &dest, uint16_t protocolNumber);
virtual bool SendFrom (Ptr<Packet> packet, const Address& source, const Address& dest, uint16_t protocolNumber);
virtual Ptr<Node> GetNode (void) const;
virtual void SetNode (Ptr<Node> node);
virtual bool NeedsArp (void) const;
virtual void SetReceiveCallback (NetDevice::ReceiveCallback cb);
virtual Address GetMulticast (Ipv6Address addr) const;
virtual void SetPromiscReceiveCallback (PromiscReceiveCallback cb);
virtual bool SupportsSendFrom (void) const;
Ptr<MobilityModel> GetMobilityModel (void) const;
void SetMobilityModel (Ptr<MobilityModel> model);
void NotifyLinkDown (void);
protected:
/**
* \brief Handler for MPI receive event
*
* \param p Packet received
*/
void DoMpiReceive (Ptr<Packet> p);
virtual void DoInitialize (void);
virtual void NotifyNewAggregate (void);
private:
/**
* \brief Assign operator
*
* The method is private, so it is DISABLED.
*
* \param o Other NetDevice
* \return New instance of the NetDevice
*/
IslNetDevice& operator = (const IslNetDevice &o);
/**
* \brief Copy constructor
*
* The method is private, so it is DISABLED.
* \param o Other NetDevice
*/
IslNetDevice (const IslNetDevice &o);
/**
* \brief Dispose of the object
*/
virtual void DoDispose (void);
private:
/**
* \returns the address of the remote device connected to this device
* through the point to point channel.
*/
Address GetRemote (void) const;
/**
* Adds the necessary headers and trailers to a packet of data in order to
* respect the protocol implemented by the agent.
* \param p packet
* \param protocolNumber protocol number
*/
void AddHeader (Ptr<Packet> p, uint16_t protocolNumber);
/**
* Removes, from a packet of data, all headers and trailers that
* relate to the protocol implemented by the agent
* \param p Packet whose headers need to be processed
* \param param An integer parameter that can be set by the function
* \return Returns true if the packet should be forwarded up the
* protocol stack.
*/
bool ProcessHeader (Ptr<Packet> p, uint16_t& param);
/**
* Start Sending a Packet Down the Wire.
*
* The TransmitStart method is the method that is used internally in the
* IslNetDevice to begin the process of sending a packet out on
* the channel. The corresponding method is called on the channel to let
* it know that the physical device this class represents has virtually
* started sending signals. An event is scheduled for the time at which
* the bits have been completely transmitted.
*
* \see IslChannel::TransmitStart ()
* \see TransmitComplete()
* \param p a reference to the packet to send
* \returns true if success, false on failure
*/
bool TransmitStart (Ptr<Packet> p, const Address &dest);
/**
* Stop Sending a Packet Down the Wire and Begin the Interframe Gap.
*
* The TransmitComplete method is used internally to finish the process
* of sending a packet out on the channel.
*/
void TransmitComplete (const Address &dest);
/**
* \brief Make the link up and running
*
* It calls also the linkChange callback.
*/
void NotifyLinkUp (void);
/**
* Enumeration of the states of the transmit machine of the net device.
*/
enum TxMachineState
{
READY, /**< The transmitter is ready to begin transmission of a packet */
BUSY /**< The transmitter is busy transmitting a packet */
};
/**
* The state of the Net Device transmit state machine.
*/
TxMachineState m_txMachineState;
/**
* The data rate that the Net Device uses to simulate packet transmission
* timing.
*/
DataRate m_bps;
/**
* The interframe gap that the Net Device uses to throttle packet
* transmission
*/
Time m_tInterframeGap;
/**
* The IslChannel to which this IslNetDevice has been
* attached.
*/
Ptr<IslChannel> m_channel;
/**
* The Queue which this IslNetDevice uses as a packet source.
* Management of this Queue has been delegated to the IslNetDevice
* and it has the responsibility for deletion.
* \see class DropTailQueue
*/
Ptr<Queue<Packet> > m_queue;
/**
* 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.
*/
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.
*/
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). This is a promiscuous trace (which doesn't mean a lot here
* in the point-to-point device).
*/
TracedCallback<Ptr<const Packet> > m_macPromiscRxTrace;
/**
* The trace source fired for packets successfully received by the device
* immediately before being forwarded up to higher layers (at the L2/L3
* transition). This is a non-promiscuous trace (which doesn't mean a lot
* here in the point-to-point device).
*/
TracedCallback<Ptr<const Packet> > m_macRxTrace;
/**
* The trace source fired for packets successfully received by the device
* but are dropped before being forwarded up to higher layers (at the L2/L3
* transition).
*/
TracedCallback<Ptr<const Packet> > m_macRxDropTrace;
/**
* The trace source fired when a packet begins the transmission process on
* the medium.
*/
TracedCallback<Ptr<const Packet> > m_phyTxBeginTrace;
/**
* The trace source fired when a packet ends the transmission process on
* the medium.
*/
TracedCallback<Ptr<const Packet> > m_phyTxEndTrace;
/**
* The trace source fired when the phy layer drops a packet before it tries
* to transmit it.
*/
TracedCallback<Ptr<const Packet> > m_phyTxDropTrace;
/**
* The trace source fired when a packet begins the reception process from
* the medium -- when the simulated first bit(s) arrive.
*/
TracedCallback<Ptr<const Packet> > m_phyRxBeginTrace;
/**
* The trace source fired when a packet ends the reception process from
* the medium.
*/
TracedCallback<Ptr<const Packet> > m_phyRxEndTrace;
/**
* 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.
*/
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 \c hard_start_xmit where
* \c 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 \c netif_receive_skb.
*/
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 \c hard_start_xmit where
* \c 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 \c netif_receive_skb.
*/
TracedCallback<Ptr<const Packet> > m_promiscSnifferTrace;
Ptr<Node> m_node; //!< Node owning this NetDevice
Ptr<NetDeviceQueueInterface> m_queueInterface; //!< NetDevice queue interface
Mac48Address m_address; //!< Mac48Address of this NetDevice
NetDevice::ReceiveCallback m_rxCallback; //!< Receive callback
NetDevice::PromiscReceiveCallback m_promiscCallback; //!< Receive callback
// (promisc data)
uint32_t m_ifIndex; //!< Index of the interface
bool m_linkUp; //!< Identify if the link is up or not
TracedCallback<> m_linkChangeCallbacks; //!< Callback for the link change event
static const uint16_t DEFAULT_MTU = 1500; //!< Default MTU
/**
* \brief The Maximum Transmission Unit
*
* This corresponds to the maximum
* number of bytes that can be transmitted as seen from higher layers.
* This corresponds to the 1500 byte MTU size often seen on IP over
* Ethernet.
*/
uint32_t m_mtu;
/**
* \brief The index into the network device list of the channel.
*
* This is written to when the device is attached.
*/
uint32_t m_channelDevId;
Ptr<Packet> m_currentPkt; //!< Current packet processed
Ptr<MobilityModel> m_mobilityModel;
/**
* \brief PPP to Ethernet protocol number mapping
* \param protocol A PPP protocol number
* \return The corresponding Ethernet protocol number
*/
static uint16_t PppToEther (uint16_t protocol);
/**
* \brief Ethernet to PPP protocol number mapping
* \param protocol An Ethernet protocol number
* \return The corresponding PPP protocol number
*/
static uint16_t EtherToPpp (uint16_t protocol);
};
} // namespace ns3
#endif /* ISL_NET_DEVICE_H */

73
model/isl-propagation-loss-model.cc Normal file
View file

@ -0,0 +1,73 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2005,2006,2007 INRIA
*
* 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
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
* Contributions: Timo Bingmann <timo.bingmann@student.kit.edu>
* Contributions: Gary Pei <guangyu.pei@boeing.com> for fixed RSS
* Contributions: Tom Hewer <tomhewer@mac.com> for two ray ground model
* Pavel Boyko <boyko@iitp.ru> for matrix
*/
#include "isl-propagation-loss-model.h"
namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("IslPropagationLossModel");
NS_OBJECT_ENSURE_REGISTERED (IslPropagationLossModel);
TypeId
IslPropagationLossModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::IslPropagationLossModel")
.SetParent<PropagationLossModel> ()
.SetGroupName ("Leo")
.AddConstructor<IslPropagationLossModel> ()
;
return tid;
}
IslPropagationLossModel::IslPropagationLossModel ()
{
}
IslPropagationLossModel::~IslPropagationLossModel ()
{
}
double
IslPropagationLossModel::DoCalcRxPower (double txPowerDbm,
Ptr<MobilityModel> a,
Ptr<MobilityModel> b) const
{
//Vector aPos = a->GetPosition ();
//Vector bPos = b->GetPosition ();
// TODO perform line-earth intersection (ray tracing)
double rxc = 0;//-m_variable->GetValue ();
NS_LOG_DEBUG ("attenuation coefficient="<<rxc<<"Db");
return txPowerDbm + rxc;
}
int64_t
IslPropagationLossModel::DoAssignStreams (int64_t stream)
{
return 0;
}
};

62
model/isl-propagation-loss-model.h Normal file
View file

@ -0,0 +1,62 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2005,2006,2007 INRIA
*
* 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
*
* Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
* Contributions: Timo Bingmann <timo.bingmann@student.kit.edu>
* Contributions: Gary Pei <guangyu.pei@boeing.com> for fixed RSS
* Contributions: Tom Hewer <tomhewer@mac.com> for two ray ground model
* Pavel Boyko <boyko@iitp.ru> for matrix
*/
#ifndef ISL_PROPAGATION_LOSS_MODEL_H
#define ISL_PROPAGATION_LOSS_MODEL_H
#include "leo-mobility-model.h"
#include <ns3/object.h>
#include <ns3/propagation-loss-model.h>
namespace ns3 {
class IslPropagationLossModel : public PropagationLossModel
{
public:
static TypeId GetTypeId (void);
IslPropagationLossModel ();
virtual ~IslPropagationLossModel ();
private:
/**
* Returns the Rx Power taking into account only the particular
* PropagationLossModel.
*
* \param txPowerDbm current transmission power (in dBm)
* \param a the mobility model of the source
* \param b the mobility model of the destination
* \returns the reception power after adding/multiplying propagation loss (in dBm)
*/
virtual double DoCalcRxPower (double txPowerDbm,
Ptr<MobilityModel> a,
Ptr<MobilityModel> b) const;
/**
* Subclasses must implement this; those not using random variables
* can return zero
*/
virtual int64_t DoAssignStreams (int64_t stream);
};
}
#endif /* SATELLITE_ISL_PROPAGATION_LOSS_MODEL_H */

69
model/leo-mobility-model.cc Normal file
View file

@ -0,0 +1,69 @@
/* -*- 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 "leo-mobility-model.h"
namespace ns3 {
NS_LOG_COMPONENT_DEFINE ("LeoMobilityModel");
NS_OBJECT_ENSURE_REGISTERED (LeoMobilityModel);
TypeId
LeoMobilityModel::GetTypeId (void)
{
static TypeId tid = TypeId ("ns3::LeoMobilityModel")
.SetParent<MobilityModel> ()
.SetGroupName ("Leo")
.AddConstructor<LeoMobilityModel> ()
;
return tid;
}
LeoMobilityModel::~LeoMobilityModel ()
{
}
Vector
LeoMobilityModel::DoGetPosition (void) const
{
// TODO
return Vector();
}
void
LeoMobilityModel::DoSetPosition (const Vector &position)
{
// TODO
}
Vector
LeoMobilityModel::DoGetVelocity (void) const
{
// TODO
return Vector();
}
int64_t
LeoMobilityModel::DoAssignStreams (int64_t start)
{
// TODO
return 0;
}
};

64
model/leo-mobility-model.h Normal file
View file

@ -0,0 +1,64 @@
/* -*- 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
*/
#ifndef LEO_MOBILITY_MODEL_H
#define LEO_MOBILITY_MODEL_H
#include "ns3/log.h"
#include "ns3/mobility-model.h"
namespace ns3 {
class LeoMobilityModel : public MobilityModel {
public:
static TypeId GetTypeId (void);
virtual ~LeoMobilityModel ();
private:
/**
* \return the current position.
*
* Concrete subclasses of this base class must
* implement this method.
*/
virtual Vector DoGetPosition (void) const;
/**
* \param position the position to set.
*
* Concrete subclasses of this base class must
* implement this method.
*/
virtual void DoSetPosition (const Vector &position);
/**
* \return the current velocity.
*
* Concrete subclasses of this base class must
* implement this method.
*/
virtual Vector DoGetVelocity (void) const;
/**
* The default implementation does nothing but return the passed-in
* parameter. Subclasses using random variables are expected to
* override this.
* \param start starting stream index
* \return the number of streams used
*/
virtual int64_t DoAssignStreams (int64_t start);
};
};
#endif /* LEO_MOBILITY_MODEL_H */

11
model/leo.cc Normal file
View file

@ -0,0 +1,11 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#include "leo.h"
namespace ns3 {
/* ... */
}

12
model/leo.h Normal file
View file

@ -0,0 +1,12 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef LEO_H
#define LEO_H
namespace ns3 {
/* ... */
}
#endif /* LEO_H */

68
test/leo-test-suite.cc Normal file
View file

@ -0,0 +1,68 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
// Include a header file from your module to test.
#include "ns3/leo.h"
// An essential include is test.h
#include "ns3/test.h"
// Do not put your test classes in namespace ns3. You may find it useful
// to use the using directive to access the ns3 namespace directly
using namespace ns3;
// This is an example TestCase.
class LeoTestCase1 : public TestCase
{
public:
LeoTestCase1 ();
virtual ~LeoTestCase1 ();
private:
virtual void DoRun (void);
};
// Add some help text to this case to describe what it is intended to test
LeoTestCase1::LeoTestCase1 ()
: TestCase ("Leo test case (does nothing)")
{
}
// This destructor does nothing but we include it as a reminder that
// the test case should clean up after itself
LeoTestCase1::~LeoTestCase1 ()
{
}
//
// This method is the pure virtual method from class TestCase that every
// TestCase must implement
//
void
LeoTestCase1::DoRun (void)
{
// A wide variety of test macros are available in src/core/test.h
NS_TEST_ASSERT_MSG_EQ (true, true, "true doesn't equal true for some reason");
// Use this one for floating point comparisons
NS_TEST_ASSERT_MSG_EQ_TOL (0.01, 0.01, 0.001, "Numbers are not equal within tolerance");
}
// The TestSuite class names the TestSuite, identifies what type of TestSuite,
// and enables the TestCases to be run. Typically, only the constructor for
// this class must be defined
//
class LeoTestSuite : public TestSuite
{
public:
LeoTestSuite ();
};
LeoTestSuite::LeoTestSuite ()
: TestSuite ("leo", UNIT)
{
// TestDuration for TestCase can be QUICK, EXTENSIVE or TAKES_FOREVER
AddTestCase (new LeoTestCase1, TestCase::QUICK);
}
// Do not forget to allocate an instance of this TestSuite
static LeoTestSuite leoTestSuite;

42
wscript Normal file
View file

@ -0,0 +1,42 @@
# -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
# def options(opt):
# pass
# def configure(conf):
# conf.check_nonfatal(header_name='stdint.h', define_name='HAVE_STDINT_H')
def build(bld):
module = bld.create_ns3_module('leo', ['core','internet', 'propagation', 'stats', 'traffic', 'flow-monitor', 'applications'])
module.source = [
'model/leo.cc',
'model/isl-net-device.cc',
'model/isl-channel.cc',
'model/isl-propagation-loss-model.cc',
'model/leo-mobility-model.cc',
'helper/leo-helper.cc',
'helper/isl-helper.cc',
]
module_test = bld.create_ns3_module_test_library('leo')
module_test.source = [
'test/leo-test-suite.cc',
]
headers = bld(features='ns3header')
headers.module = 'leo'
headers.source = [
'model/leo.h',
'model/isl-net-device.h',
'model/isl-channel.h',
'model/isl-propagation-loss-model.h',
'model/leo-mobility-model.h',
'helper/leo-helper.h',
'helper/isl-helper.h',
]
if bld.env.ENABLE_EXAMPLES:
bld.recurse('examples')
# bld.ns3_python_bindings()