27 #include "ns3/config.h"
28 #include "ns3/uinteger.h"
29 #include "ns3/socket-factory.h"
30 #include "ns3/ipv4-raw-socket-factory.h"
31 #include "ns3/ipv6-raw-socket-factory.h"
32 #include "ns3/udp-socket-factory.h"
33 #include "ns3/simulator.h"
35 #include "ns3/simple-net-device.h"
36 #include "ns3/drop-tail-queue.h"
37 #include "ns3/socket.h"
38 #include "ns3/udp-socket.h"
42 #include "ns3/inet-socket-address.h"
43 #include "ns3/boolean.h"
45 #include "ns3/ipv6-static-routing.h"
46 #include "ns3/ipv6-list-routing.h"
47 #include "ns3/inet6-socket-address.h"
49 #include "ns3/arp-l3-protocol.h"
50 #include "ns3/ipv4-l3-protocol.h"
51 #include "ns3/icmpv4-l4-protocol.h"
52 #include "ns3/ipv4-list-routing.h"
53 #include "ns3/ipv4-static-routing.h"
54 #include "ns3/udp-l4-protocol.h"
56 #include "ns3/ipv6-l3-protocol.h"
57 #include "ns3/icmpv6-l4-protocol.h"
58 #include "ns3/traffic-control-layer.h"
62 #include <netinet/in.h>
83 virtual void Print (std::ostream &os)
const { os <<
"token=" << token; }
84 void setToken (uint64_t token) { this->token = token; }
98 ipv6Routing->AddRoutingProtocol (ipv6staticRouting, 0);
135 virtual void DoRun (
void);
146 void HandleReadIcmpClient (
Ipv6Address icmpSource, uint8_t icmpTtl, uint8_t icmpType,
147 uint8_t icmpCode,uint32_t icmpInfo);
149 void SetFill (uint8_t *fill, uint32_t fillSize, uint32_t dataSize);
156 :
TestCase (
"Verify the IPv6 layer 3 protocol fragmentation and reassembly")
180 TypeId tid = TypeId::LookupByName (
"ns3::UdpSocketFactory");
195 while ((packet = socket->
RecvFrom (from)))
197 if (Inet6SocketAddress::IsMatchingType (from))
210 TypeId tid = TypeId::LookupByName (
"ns3::UdpSocketFactory");
226 while ((packet = socket->
RecvFrom (from)))
228 if (Inet6SocketAddress::IsMatchingType (from))
237 uint8_t icmpTtl, uint8_t icmpType,
238 uint8_t icmpCode, uint32_t icmpInfo)
250 m_data =
new uint8_t [dataSize];
254 if (fillSize >= dataSize)
256 memcpy (
m_data, fill, dataSize);
261 while (filled + fillSize < dataSize)
263 memcpy (&
m_data[filled], fill, fillSize);
267 memcpy (&
m_data[filled], fill, dataSize - filled);
281 p = Create<Packet> (
m_size);
299 Ptr<Node> serverNode = CreateObject<Node> ();
304 serverDev = CreateObject<SimpleNetDevice> ();
305 serverDev->
SetAddress (Mac48Address::ConvertFrom (Mac48Address::Allocate ()));
308 serverDevErrorModel->
Disable ();
314 ipv6->
SetUp (netdev_idx);
319 Ptr<Node> clientNode = CreateObject<Node> ();
324 clientDev = CreateObject<SimpleNetDevice> ();
325 clientDev->
SetAddress (Mac48Address::ConvertFrom (Mac48Address::Allocate ()));
328 clientDevErrorModel->
Disable ();
334 ipv6->
SetUp (netdev_idx);
346 uint32_t packetSizes[5] = {2000, 2500, 5000, 10000, 65000};
349 uint8_t fillData[78];
350 for ( uint32_t k = 48; k <= 125; k++ )
352 fillData[k - 48] = k;
356 for (
int i = 0; i < 5; i++)
360 SetFill (fillData, 78, packetSize);
367 uint8_t recvBuffer[65000];
372 "Packet size not correct: recvSize: " << recvSize <<
" packetSizes[" << i <<
"]: " << packetSizes[i] );
376 0,
"Packet content differs");
383 for (
int i = 0; i < 5; i++)
387 SetFill (fillData, 78, packetSize);
394 uint8_t recvBuffer[65000];
399 "Packet size not correct: recvSize: " << recvSize <<
" packetSizes[" << i <<
"]: " << packetSizes[i] );
403 0,
"Packet content differs");
414 clientDevErrorModel->
Disable ();
415 serverDevErrorModel->
Enable ();
416 for (
int i = 1; i < 5; i++)
420 SetFill (fillData, 78, packetSize);
423 serverDevErrorModel->
Reset ();
436 && (
m_icmpCode == Icmpv6Header::ICMPV6_FRAGTIME),
437 true,
"Client did not receive ICMPv6::TIME_EXCEEDED " <<
int(m_icmpType) <<
int(
m_icmpCode) );
442 clientDevErrorModel->
Disable ();
443 serverDevErrorModel->
Disable ();
444 for (
int i= 0; i<5; i++)
448 SetFill (fillData, 78, packetSize);
464 uint32_t tagStart = 0;
466 while (iter.HasNext ())
490 Simulator::Destroy ();
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Access to the IPv6 forwarding table, interfaces, and configuration.
void WriteU64(uint64_t v)
static TypeId GetTypeId()
void AddPacketTag(const Tag &tag) const
Add a packet tag.
void AggregateObject(Ptr< Object > other)
Aggregate two Objects together.
virtual uint32_t GetSerializedSize() const
IPv6 address associated with an interface.
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
virtual void Print(std::ostream &os) const
Ptr< Packet > m_receivedPacketClient
void StartServer(Ptr< Node > ServerNode)
A sockets interface to UDP.
a polymophic address class
Callback< ObjectBase * > GetConstructor(void) const
Get the constructor callback.
AttributeValue implementation for Callback.
bool PeekPacketTag(Tag &tag) const
Search a matching tag and call Tag::Deserialize if it is found.
Identifies a byte tag and a set of bytes within a packet to which the tag applies.
void HandleReadIcmpClient(Ipv6Address icmpSource, uint8_t icmpTtl, uint8_t icmpType, uint8_t icmpCode, uint32_t icmpInfo)
Ipv6FragmentationTestSuite()
void AddTestCase(TestCase *testCase, enum TestDuration duration)
Add an individual child TestCase to this test suite.
virtual bool SetMtu(const uint16_t mtu)
Ptr< Socket > m_socketServer
Ptr< Packet > m_receivedPacketServer
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
ByteTagIterator GetByteTagIterator(void) const
Retiurns an iterator over the set of byte tags included in this packet.
void HandleReadClient(Ptr< Socket > socket)
void SetRecvCallback(Callback< void, Ptr< Socket > >)
Notify application when new data is available to be read.
uint32_t GetEnd(void) const
The index is an offset from the start of the packet.
void Disable(void)
Disable the error model.
virtual void Deserialize(TagBuffer buffer)
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
void SetJumpingMode(bool mode)
Set if the odd packets are delayed (even ones are not delayed ever)
Ptr< Packet > Copy(void) const
performs a COW copy of the packet.
tag a set of bytes in a packet
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
Iterator over the set of byte tags in a packet.
#define NS_TEST_EXPECT_MSG_NE(actual, limit, msg)
Test that an actual and expected (limit) value are not equal and report if not.
std::string GetName(void) const
Get the name.
void SetReceiveErrorModel(Ptr< ErrorModel > em)
Attach a receive ErrorModel to the SimpleNetDevice.
TypeId GetTypeId(void) const
Ptr< Packet > m_sentPacketClient
virtual TypeId GetInstanceTypeId() const
Get the most derived TypeId for this Object.
void HandleReadServer(Ptr< Socket > socket)
Ptr< Packet > SendClient(void)
virtual uint32_t AddInterface(Ptr< NetDevice > device)=0
Add a NetDevice interface.
void GetTag(Tag &tag) const
Read the requested tag and store it in the user-provided tag instance.
virtual void DoRun(void)
Implementation to actually run this TestCase.
virtual void RegisterExtensions()
Register the IPv6 Extensions.
Describes an IPv6 address.
void SetRoutingProtocol(Ptr< Ipv6RoutingProtocol > routingProtocol)
Set routing protocol for this stack.
uint32_t GetStart(void) const
The index is an offset from the start of the packet.
uint32_t AddDevice(Ptr< NetDevice > device)
Associate a NetDevice to this node.
uint32_t GetId(void) const
virtual Ptr< Node > GetNode(void) const =0
Return the node this socket is associated with.
Ptr< Socket > m_socketClient
virtual void Serialize(TagBuffer buffer) const
virtual void SetAddress(Address address)
Set the address of this interface.
Time Seconds(double value)
Construct a Time in the indicated unit.
void SetFill(uint8_t *fill, uint32_t fillSize, uint32_t dataSize)
virtual void RegisterOptions()
Register the IPv6 Options.
void setToken(uint64_t token)
Describes an IPv6 prefix.
virtual bool AddAddress(uint32_t interface, Ipv6InterfaceAddress address)=0
Add an address on the specified IPv6 interface.
uint32_t CopyData(uint8_t *buffer, uint32_t size) const
Copy the packet contents to a byte buffer.
void SetJumpingTime(Time delay)
Set the delay for the odd packets (even ones are not delayed)
static const uint32_t packetSize
void StartClient(Ptr< Node > ClientNode)
Ipv6FragmentationTestSuite g_ipv6fragmentationTestSuite
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.
This test suite implements a Unit Test.
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
static void AddInternetStack(Ptr< Node > node)
void SetChannel(Ptr< SimpleChannel > channel)
Attach a channel to this net device.
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
a unique identifier for an interface.
TypeId SetParent(TypeId tid)
Set the parent TypeId.
void Enable(void)
Enable the error model.
virtual void SetUp(uint32_t interface)=0
Set the interface into the "up" state.
void AddByteTag(const Tag &tag) const
Tag each byte included in this packet with a new byte tag.