25#include "ns3/arp-l3-protocol.h"
26#include "ns3/boolean.h"
27#include "ns3/config.h"
28#include "ns3/error-channel.h"
29#include "ns3/icmpv4-l4-protocol.h"
30#include "ns3/icmpv6-l4-protocol.h"
31#include "ns3/inet-socket-address.h"
32#include "ns3/inet6-socket-address.h"
33#include "ns3/internet-stack-helper.h"
34#include "ns3/ipv4-l3-protocol.h"
35#include "ns3/ipv4-list-routing.h"
36#include "ns3/ipv4-raw-socket-factory.h"
37#include "ns3/ipv4-static-routing.h"
38#include "ns3/ipv6-l3-protocol.h"
39#include "ns3/ipv6-list-routing.h"
40#include "ns3/ipv6-raw-socket-factory.h"
41#include "ns3/ipv6-static-routing.h"
44#include "ns3/simple-net-device.h"
45#include "ns3/simulator.h"
46#include "ns3/socket-factory.h"
47#include "ns3/socket.h"
49#include "ns3/traffic-control-layer.h"
50#include "ns3/udp-l4-protocol.h"
51#include "ns3/udp-socket-factory.h"
52#include "ns3/udp-socket.h"
53#include "ns3/uinteger.h"
56#include "ns3/win32-internet.h"
58#include <netinet/in.h>
110 void Print(std::ostream& os)
const override
112 os <<
"token=" <<
token;
155 void DoRun()
override;
234 :
TestCase(
"Verify the IPv6 layer 3 protocol fragmentation and reassembly")
259 TypeId tid = TypeId::LookupByName(
"ns3::UdpSocketFactory");
274 while ((packet = socket->
RecvFrom(from)))
276 if (Inet6SocketAddress::IsMatchingType(from))
288 TypeId tid = TypeId::LookupByName(
"ns3::UdpSocketFactory");
304 while ((packet = socket->
RecvFrom(from)))
306 if (Inet6SocketAddress::IsMatchingType(from))
330 m_data =
new uint8_t[dataSize];
334 if (fillSize >= dataSize)
336 memcpy(
m_data, fill, dataSize);
341 while (filled + fillSize < dataSize)
343 memcpy(&
m_data[filled], fill, fillSize);
347 memcpy(&
m_data[filled], fill, dataSize - filled);
362 p = Create<Packet>(
m_size);
378 ipv6->GetMtu(interface),
379 "Received packet size > MTU: packetSizes: " << packet->
GetSize());
387 ipv6->GetMtu(interface),
388 "Transmitted packet size > MTU: packetSizes: " << packet->
GetSize());
400 Ptr<Node> serverNode = CreateObject<Node>();
405 serverDev = CreateObject<SimpleNetDevice>();
406 serverDev->SetAddress(Mac48Address::ConvertFrom(Mac48Address::Allocate()));
407 serverDev->SetMtu(1500);
408 serverDev->SetReceiveErrorModel(serverDevErrorModel);
409 serverDevErrorModel->Disable();
412 uint32_t netdev_idx = ipv6->AddInterface(serverDev);
415 ipv6->AddAddress(netdev_idx, ipv6Addr);
416 ipv6->SetUp(netdev_idx);
417 ipv6->TraceConnectWithoutContext(
424 Ptr<Node> clientNode = CreateObject<Node>();
429 clientDev = CreateObject<SimpleNetDevice>();
430 clientDev->SetAddress(Mac48Address::ConvertFrom(Mac48Address::Allocate()));
431 clientDev->SetMtu(1500);
432 clientDev->SetReceiveErrorModel(clientDevErrorModel);
433 clientDevErrorModel->Disable();
436 uint32_t netdev_idx = ipv6->AddInterface(clientDev);
439 ipv6->AddAddress(netdev_idx, ipv6Addr);
440 ipv6->SetUp(netdev_idx);
441 ipv6->TraceConnectWithoutContext(
449 serverDev->SetChannel(
channel);
450 clientDev->SetChannel(
channel);
454 uint32_t packetSizes[5] = {1500, 2000, 5000, 10000, 65000};
457 uint8_t fillData[78];
460 fillData[
k - 48] =
k;
464 for (
int i = 0; i < 5; i++)
477 uint8_t recvBuffer[65000];
483 "Packet size not correct: recvSize: "
484 << recvSize <<
" packetSizes[" << i <<
"]: " << packetSizes[i]);
489 "Packet content differs");
496 for (
int i = 0; i < 5; i++)
509 uint8_t recvBuffer[65000];
515 "Packet size not correct: recvSize: "
516 << recvSize <<
" packetSizes[" << i <<
"]: " << packetSizes[i]);
521 "Packet content differs");
523 channel->SetJumpingMode(
false);
532 clientDevErrorModel->Disable();
533 serverDevErrorModel->Enable();
534 for (
int i = 1; i < 5; i++)
541 serverDevErrorModel->Reset();
556 (
m_icmpCode == Icmpv6Header::ICMPV6_FRAGTIME),
558 "Client did not receive ICMPv6::TIME_EXCEEDED " <<
int(
m_icmpType)
564 clientDevErrorModel->Disable();
565 serverDevErrorModel->Disable();
566 for (
int i = 0; i < 5; i++)
595 "ByteTag name not correct");
616 Simulator::Destroy();
Tag used in IPv6 Fragmentation Test.
void Serialize(TagBuffer buffer) const override
static TypeId GetTypeId()
Get the type ID.
TypeId GetInstanceTypeId() const override
Get the most derived TypeId for this Object.
uint64_t GetToken()
Get the token.
uint64_t token
Token carried by the tag.
void Print(std::ostream &os) const override
void Deserialize(TagBuffer buffer) override
uint32_t GetSerializedSize() const override
void SetToken(uint64_t token)
Set the token.
void HandleReadServer(Ptr< Socket > socket)
Handle incoming packets.
Ptr< Socket > m_socketClient
Client socket.
uint32_t m_dataSize
Data size.
void SetFill(uint8_t *fill, uint32_t fillSize, uint32_t dataSize)
Set the packet fill.
uint8_t m_icmpCode
ICMP code.
void HandleReadIcmpClient(Ipv6Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo)
Handle incoming ICMP packets.
Ptr< Socket > m_socketServer
Server socket.
void DoRun() override
Implementation to actually run this TestCase.
void StartServer(Ptr< Node > ServerNode)
Start the server.
~Ipv6FragmentationTest() override
Ptr< Packet > m_receivedPacketServer
Packet received by server.
Ptr< Packet > m_sentPacketClient
Packet sent by client.
void HandleReadClient(Ptr< Socket > socket)
Handle incoming packets.
Ptr< Packet > SendClient()
Send a packet.
void HandleServerRx(Ptr< const Packet > packet, Ptr< Ipv6 > ipv6, uint32_t interface)
Handle Server's incoming packets.
void HandleClientTx(Ptr< const Packet > packet, Ptr< Ipv6 > ipv6, uint32_t interface)
Handle Client's transmitting packets.
uint8_t m_icmpType
ICMP type.
uint32_t m_size
packet size.
Ptr< Packet > m_receivedPacketClient
Packet received by client.
void StartClient(Ptr< Node > ClientNode)
Start the client.
IPv6 Fragmentation TestSuite.
Ipv6FragmentationTestSuite()
a polymophic address class
Identifies a byte tag and a set of bytes within a packet to which the tag applies.
uint32_t GetEnd() const
The index is an offset from the start of the packet.
void GetTag(Tag &tag) const
Read the requested tag and store it in the user-provided tag instance.
uint32_t GetStart() const
The index is an offset from the start of the packet.
Iterator over the set of byte tags in a packet.
AttributeValue implementation for Callback.
aggregate IP/TCP/UDP functionality to existing Nodes.
void SetIpv4StackInstall(bool enable)
Enable/disable IPv4 stack install.
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Describes an IPv6 address.
Access to the IPv6 forwarding table, interfaces, and configuration.
IPv6 address associated with an interface.
Describes an IPv6 prefix.
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
uint32_t GetSize() const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
Ptr< Packet > Copy() const
performs a COW copy of the packet.
void AddPacketTag(const Tag &tag) const
Add a packet tag.
void AddByteTag(const Tag &tag) const
Tag each byte included in this packet with a new byte tag.
bool PeekPacketTag(Tag &tag) const
Search a matching tag and call Tag::Deserialize if it is found.
ByteTagIterator GetByteTagIterator() const
Returns an iterator over the set of byte tags included in this packet.
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
virtual Ptr< Packet > RecvFrom(uint32_t maxSize, uint32_t flags, Address &fromAddress)=0
Read a single packet from the socket and retrieve the sender address.
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
virtual Ptr< Node > GetNode() const =0
Return the node this socket is associated with.
void WriteU64(uint64_t v)
tag a set of bytes in a packet
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
@ UNIT
This test suite implements a Unit Test.
a unique identifier for an interface.
Callback< ObjectBase * > GetConstructor() const
Get the constructor callback.
TypeId SetParent(TypeId tid)
Set the parent TypeId.
std::string GetName() const
Get the name.
A sockets interface to UDP.
#define NS_TEST_EXPECT_MSG_LT_OR_EQ(actual, limit, msg)
Test that an actual value is less than or equal to a limit and report if not.
#define NS_TEST_EXPECT_MSG_NE(actual, limit, msg)
Test that an actual and expected (limit) value are not equal and report if not.
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Time Seconds(double value)
Construct a Time in the indicated unit.
static Ipv6FragmentationTestSuite g_ipv6fragmentationTestSuite
Static variable for test initialization.
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
static const uint32_t packetSize
Packet size generated at the AP.