dc/d24/udp-test_8cc_source.html

/*

 * Copyright (c) 2007 Georgia Tech Research Corporation

 *

 * 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: Raj Bhattacharjea <raj.b@gatech.edu>

 */

#include "ns3/arp-l3-protocol.h"

#include "ns3/boolean.h"

#include "ns3/icmpv4-l4-protocol.h"

#include "ns3/icmpv6-l4-protocol.h"

#include "ns3/inet-socket-address.h"

#include "ns3/inet6-socket-address.h"

#include "ns3/internet-stack-helper.h"

#include "ns3/ipv4-l3-protocol.h"

#include "ns3/ipv4-list-routing.h"

#include "ns3/ipv4-queue-disc-item.h"

#include "ns3/ipv4-static-routing.h"

#include "ns3/ipv6-address-helper.h"

#include "ns3/ipv6-l3-protocol.h"

#include "ns3/ipv6-list-routing.h"

#include "ns3/ipv6-static-routing.h"

#include "ns3/log.h"

#include "ns3/node.h"

#include "ns3/simple-channel.h"

#include "ns3/simple-net-device-helper.h"

#include "ns3/simple-net-device.h"

#include "ns3/simulator.h"

#include "ns3/socket-factory.h"

#include "ns3/socket.h"

#include "ns3/tcp-l4-protocol.h"

#include "ns3/test.h"

#include "ns3/traffic-control-helper.h"

#include "ns3/udp-l4-protocol.h"

#include "ns3/udp-socket-factory.h"


#include <limits>

#include <string>


using namespace ns3;


class UdpSocketLoopbackTest : public TestCase

{

  public:

    UdpSocketLoopbackTest();

    void DoRun() override;


    void ReceivePkt(Ptr<Socket> socket);

    Ptr<Packet> m_receivedPacket;

};


UdpSocketLoopbackTest::UdpSocketLoopbackTest()

    : TestCase("UDP loopback test")

{

}


void

UdpSocketLoopbackTest::ReceivePkt(Ptr<Socket> socket)

{

    uint32_t availableData;

    availableData = socket->GetRxAvailable();

    m_receivedPacket = socket->Recv(std::numeric_limits<uint32_t>::max(), 0);

    NS_TEST_ASSERT_MSG_EQ(availableData,

                          m_receivedPacket->GetSize(),

                          "ReceivedPacket size is not equal to the Rx buffer size");

}


void

UdpSocketLoopbackTest::DoRun()

{

    Ptr<Node> rxNode = CreateObject<Node>();

    InternetStackHelper internet;

    internet.Install(rxNode);


    Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory>();

    Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket();

    rxSocket->Bind(InetSocketAddress(Ipv4Address::GetAny(), 80));

    rxSocket->SetRecvCallback(MakeCallback(&UdpSocketLoopbackTest::ReceivePkt, this));


    Ptr<Socket> txSocket = rxSocketFactory->CreateSocket();

    txSocket->SendTo(Create<Packet>(246), 0, InetSocketAddress("127.0.0.1", 80));

    Simulator::Run();

    Simulator::Destroy();

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(),

                          246,

                          "first socket should not receive it (it is bound specifically to the "

                          "second interface's address");

}


class Udp6SocketLoopbackTest : public TestCase

{

  public:

    Udp6SocketLoopbackTest();

    void DoRun() override;


    void ReceivePkt(Ptr<Socket> socket);

    Ptr<Packet> m_receivedPacket;

};


Udp6SocketLoopbackTest::Udp6SocketLoopbackTest()

    : TestCase("UDP6 loopback test")

{

}


void

Udp6SocketLoopbackTest::ReceivePkt(Ptr<Socket> socket)

{

    uint32_t availableData [[maybe_unused]] = socket->GetRxAvailable();

    m_receivedPacket = socket->Recv(std::numeric_limits<uint32_t>::max(), 0);

    NS_TEST_ASSERT_MSG_EQ(availableData,

                          m_receivedPacket->GetSize(),

                          "ReceivedPacket size is not equal to the Rx buffer size");

}


void

Udp6SocketLoopbackTest::DoRun()

{

    Ptr<Node> rxNode = CreateObject<Node>();

    InternetStackHelper internet;

    internet.Install(rxNode);


    Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory>();

    Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket();

    rxSocket->Bind(Inet6SocketAddress(Ipv6Address::GetAny(), 80));

    rxSocket->SetRecvCallback(MakeCallback(&Udp6SocketLoopbackTest::ReceivePkt, this));


    Ptr<Socket> txSocket = rxSocketFactory->CreateSocket();

    txSocket->SendTo(Create<Packet>(246), 0, Inet6SocketAddress("::1", 80));

    Simulator::Run();

    Simulator::Destroy();

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(),

                          246,

                          "first socket should not receive it (it is bound specifically to the "

                          "second interface's address");

}


class UdpSocketImplTest : public TestCase

{

    Ptr<Packet> m_receivedPacket;

    Ptr<Packet> m_receivedPacket2;

    Ptr<Ipv4QueueDiscItem> m_sentPacket;


    uint32_t GetTos();


    uint32_t GetPriority();


    void DoSendDataTo(Ptr<Socket> socket, std::string to);

    void SendDataTo(Ptr<Socket> socket, std::string to);

    void DoSendData(Ptr<Socket> socket);

    void SendData(Ptr<Socket> socket);


  public:

    void DoRun() override;

    UdpSocketImplTest();


    void ReceivePkt(Ptr<Socket> socket);

    void ReceivePkt2(Ptr<Socket> socket);


    void SentPkt(Ptr<const QueueDiscItem> item);

};


UdpSocketImplTest::UdpSocketImplTest()

    : TestCase("UDP socket implementation")

{

}


void

UdpSocketImplTest::ReceivePkt(Ptr<Socket> socket)

{

    uint32_t availableData;

    availableData = socket->GetRxAvailable();

    m_receivedPacket = socket->Recv(std::numeric_limits<uint32_t>::max(), 0);

    NS_TEST_ASSERT_MSG_EQ(availableData,

                          m_receivedPacket->GetSize(),

                          "ReceivedPacket size is not equal to the Rx buffer size");

}


void

UdpSocketImplTest::ReceivePkt2(Ptr<Socket> socket)

{

    uint32_t availableData;

    availableData = socket->GetRxAvailable();

    m_receivedPacket2 = socket->Recv(std::numeric_limits<uint32_t>::max(), 0);

    NS_TEST_ASSERT_MSG_EQ(availableData,

                          m_receivedPacket2->GetSize(),

                          "ReceivedPacket size is not equal to the Rx buffer size");

}


void

UdpSocketImplTest::SentPkt(Ptr<const QueueDiscItem> item)

{

    Ptr<const Ipv4QueueDiscItem> ipv4Item = DynamicCast<const Ipv4QueueDiscItem>(item);

    NS_TEST_EXPECT_MSG_NE(ipv4Item, nullptr, "no IPv4 packet");

    Address addr;

    m_sentPacket =

        Create<Ipv4QueueDiscItem>(ipv4Item->GetPacket()->Copy(), addr, 0, ipv4Item->GetHeader());

}


uint32_t

UdpSocketImplTest::GetTos()

{

    return static_cast<uint32_t>(m_sentPacket->GetHeader().GetTos());

}


uint32_t

UdpSocketImplTest::GetPriority()

{

    SocketPriorityTag priorityTag;

    bool found = m_sentPacket->GetPacket()->PeekPacketTag(priorityTag);

    NS_TEST_EXPECT_MSG_EQ(found, true, "the packet should carry a SocketPriorityTag");

    return static_cast<uint32_t>(priorityTag.GetPriority());

}


void

UdpSocketImplTest::DoSendDataTo(Ptr<Socket> socket, std::string to)

{

    Address realTo = InetSocketAddress(Ipv4Address(to.c_str()), 1234);

    NS_TEST_EXPECT_MSG_EQ(socket->SendTo(Create<Packet>(123), 0, realTo), 123, "100");

}


void

UdpSocketImplTest::SendDataTo(Ptr<Socket> socket, std::string to)

{

    m_receivedPacket = Create<Packet>();

    m_receivedPacket2 = Create<Packet>();

    Simulator::ScheduleWithContext(socket->GetNode()->GetId(),

                                   Seconds(0),

                                   &UdpSocketImplTest::DoSendDataTo,

                                   this,

                                   socket,

                                   to);

    Simulator::Run();

}


void

UdpSocketImplTest::DoSendData(Ptr<Socket> socket)

{

    NS_TEST_EXPECT_MSG_EQ(socket->Send(Create<Packet>(123), 0), 123, "100");

}


void

UdpSocketImplTest::SendData(Ptr<Socket> socket)

{

    Simulator::ScheduleWithContext(socket->GetNode()->GetId(),

                                   Seconds(0),

                                   &UdpSocketImplTest::DoSendData,

                                   this,

                                   socket);

    Simulator::Run();

}


void

UdpSocketImplTest::DoRun()

{

    // Create topology


    // Receiver Node

    Ptr<Node> rxNode = CreateObject<Node>();

    // Sender Node

    Ptr<Node> txNode = CreateObject<Node>();


    NodeContainer nodes(rxNode, txNode);


    SimpleNetDeviceHelper helperChannel1;

    helperChannel1.SetNetDevicePointToPointMode(true);

    NetDeviceContainer net1 = helperChannel1.Install(nodes);


    SimpleNetDeviceHelper helperChannel2;

    helperChannel2.SetNetDevicePointToPointMode(true);

    NetDeviceContainer net2 = helperChannel2.Install(nodes);


    InternetStackHelper internet;

    internet.Install(nodes);


    TrafficControlHelper tch = TrafficControlHelper::Default();

    QueueDiscContainer qdiscs = tch.Install(net1.Get(1));


    Ptr<Ipv4> ipv4;

    uint32_t netdev_idx;

    Ipv4InterfaceAddress ipv4Addr;


    // Receiver Node

    ipv4 = rxNode->GetObject<Ipv4>();

    netdev_idx = ipv4->AddInterface(net1.Get(0));

    ipv4Addr = Ipv4InterfaceAddress(Ipv4Address("10.0.0.1"), Ipv4Mask("/24"));

    ipv4->AddAddress(netdev_idx, ipv4Addr);

    ipv4->SetUp(netdev_idx);


    netdev_idx = ipv4->AddInterface(net2.Get(0));

    ipv4Addr = Ipv4InterfaceAddress(Ipv4Address("10.0.1.1"), Ipv4Mask("/24"));

    ipv4->AddAddress(netdev_idx, ipv4Addr);

    ipv4->SetUp(netdev_idx);


    // Sender Node

    ipv4 = txNode->GetObject<Ipv4>();

    netdev_idx = ipv4->AddInterface(net1.Get(1));

    ipv4Addr = Ipv4InterfaceAddress(Ipv4Address("10.0.0.2"), Ipv4Mask("/24"));

    ipv4->AddAddress(netdev_idx, ipv4Addr);

    ipv4->SetUp(netdev_idx);


    netdev_idx = ipv4->AddInterface(net2.Get(1));

    ipv4Addr = Ipv4InterfaceAddress(Ipv4Address("10.0.1.2"), Ipv4Mask("/24"));

    ipv4->AddAddress(netdev_idx, ipv4Addr);

    ipv4->SetUp(netdev_idx);


    // Create the UDP sockets

    Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory>();


    Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket();

    NS_TEST_EXPECT_MSG_EQ(rxSocket->Bind(InetSocketAddress(Ipv4Address("10.0.0.1"), 1234)),

                          0,

                          "trivial");

    rxSocket->SetRecvCallback(MakeCallback(&UdpSocketImplTest::ReceivePkt, this));


    Ptr<Socket> rxSocket2 = rxSocketFactory->CreateSocket();

    NS_TEST_EXPECT_MSG_EQ(rxSocket2->Bind(InetSocketAddress(Ipv4Address("10.0.1.1"), 1234)),

                          0,

                          "trivial");

    rxSocket2->SetRecvCallback(MakeCallback(&UdpSocketImplTest::ReceivePkt2, this));


    Ptr<SocketFactory> txSocketFactory = txNode->GetObject<UdpSocketFactory>();

    Ptr<Socket> txSocket = txSocketFactory->CreateSocket();

    txSocket->SetAllowBroadcast(true);


    // ------ Now the tests ------------


    // Unicast test

    SendDataTo(txSocket, "10.0.0.1");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(), 123, "trivial");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket2->GetSize(),

                          0,

                          "second interface should not receive it");


    m_receivedPacket->RemoveAllByteTags();

    m_receivedPacket2->RemoveAllByteTags();


    // Simple broadcast test


    SendDataTo(txSocket, "255.255.255.255");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(),

                          0,

                          "first socket should not receive it (it is bound specifically to the "

                          "first interface's address");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket2->GetSize(),

                          0,

                          "second socket should not receive it (it is bound specifically to the "

                          "second interface's address");


    m_receivedPacket->RemoveAllByteTags();

    m_receivedPacket2->RemoveAllByteTags();


    // Broadcast test with multiple receiving sockets


    // When receiving broadcast packets, all sockets sockets bound to

    // the address/port should receive a copy of the same packet -- if

    // the socket address matches.

    rxSocket2->Dispose();

    rxSocket2 = rxSocketFactory->CreateSocket();

    rxSocket2->SetRecvCallback(MakeCallback(&UdpSocketImplTest::ReceivePkt2, this));

    NS_TEST_EXPECT_MSG_EQ(rxSocket2->Bind(InetSocketAddress(Ipv4Address("0.0.0.0"), 1234)),

                          0,

                          "trivial");


    SendDataTo(txSocket, "255.255.255.255");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(),

                          0,

                          "first socket should not receive it (it is bound specifically to the "

                          "first interface's address");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket2->GetSize(), 123, "trivial");


    m_receivedPacket = nullptr;

    m_receivedPacket2 = nullptr;


    // Simple Link-local multicast test


    txSocket->BindToNetDevice(net1.Get(1));

    SendDataTo(txSocket, "224.0.0.9");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(),

                          0,

                          "first socket should not receive it (it is bound specifically to the "

                          "first interface's address");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket2->GetSize(), 123, "recv2: 224.0.0.9");


    m_receivedPacket->RemoveAllByteTags();

    m_receivedPacket2->RemoveAllByteTags();


    // Simple getpeername tests


    Address peerAddress;

    int err = txSocket->GetPeerName(peerAddress);

    NS_TEST_EXPECT_MSG_EQ(err, -1, "socket GetPeerName() should fail when socket is not connected");

    NS_TEST_EXPECT_MSG_EQ(txSocket->GetErrno(),

                          Socket::ERROR_NOTCONN,

                          "socket error code should be ERROR_NOTCONN");


    InetSocketAddress peer("10.0.0.1", 1234);

    err = txSocket->Connect(peer);

    NS_TEST_EXPECT_MSG_EQ(err, 0, "socket Connect() should succeed");


    err = txSocket->GetPeerName(peerAddress);

    NS_TEST_EXPECT_MSG_EQ(err, 0, "socket GetPeerName() should succeed when socket is connected");

    NS_TEST_EXPECT_MSG_EQ(peerAddress,

                          peer,

                          "address from socket GetPeerName() should equal the connected address");


    m_receivedPacket->RemoveAllByteTags();

    m_receivedPacket2->RemoveAllByteTags();


    // TOS and priority tests


    // Intercept the packets dequeued by the queue disc on the sender node

    qdiscs.Get(0)->TraceConnectWithoutContext("Dequeue",

                                              MakeCallback(&UdpSocketImplTest::SentPkt, this));


    // The socket is not connected.

    txSocket->SetIpTos(0x28); // AF11

    txSocket->SetPriority(6); // Interactive

    // Send a packet to a specified destination:

    // - for not connected sockets, the tos specified in the destination address (0) is used

    // - since the tos is zero, the priority set for the socket is used

    SendDataTo(txSocket, "10.0.0.1");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(), 123, "trivial");


    NS_TEST_EXPECT_MSG_EQ(GetTos(), 0, "the TOS should be set to 0");

    NS_TEST_EXPECT_MSG_EQ(GetPriority(), 6, "Interactive (6)");


    m_receivedPacket->RemoveAllByteTags();


    InetSocketAddress dest("10.0.0.1", 1234);

    dest.SetTos(0xb8); // EF

    // the connect operation sets the tos (and priority) for the socket

    NS_TEST_EXPECT_MSG_EQ(txSocket->Connect(dest), 0, "the connect operation failed");


    SendData(txSocket);

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(), 123, "trivial");


    NS_TEST_EXPECT_MSG_EQ(GetTos(), 0xb8, "the TOS should be set to 0xb8");

    NS_TEST_EXPECT_MSG_EQ(GetPriority(), 4, "Interactive bulk (4)");


    m_receivedPacket->RemoveAllByteTags();


    Simulator::Destroy();

}


class Udp6SocketImplTest : public TestCase

{

    Ptr<Packet> m_receivedPacket;

    Ptr<Packet> m_receivedPacket2;


    void DoSendDataTo(Ptr<Socket> socket, std::string to);

    void SendDataTo(Ptr<Socket> socket, std::string to);


  public:

    void DoRun() override;

    Udp6SocketImplTest();


    void ReceivePacket(Ptr<Socket> socket, Ptr<Packet> packet, const Address& from);

    void ReceivePacket2(Ptr<Socket> socket, Ptr<Packet> packet, const Address& from);

    void ReceivePkt(Ptr<Socket> socket);

    void ReceivePkt2(Ptr<Socket> socket);

};


Udp6SocketImplTest::Udp6SocketImplTest()

    : TestCase("UDP6 socket implementation")

{

}


void

Udp6SocketImplTest::ReceivePacket(Ptr<Socket> socket, Ptr<Packet> packet, const Address& from)

{

    m_receivedPacket = packet;

}


void

Udp6SocketImplTest::ReceivePacket2(Ptr<Socket> socket, Ptr<Packet> packet, const Address& from)

{

    m_receivedPacket2 = packet;

}


void

Udp6SocketImplTest::ReceivePkt(Ptr<Socket> socket)

{

    uint32_t availableData [[maybe_unused]] = socket->GetRxAvailable();

    m_receivedPacket = socket->Recv(std::numeric_limits<uint32_t>::max(), 0);

    NS_TEST_ASSERT_MSG_EQ(availableData,

                          m_receivedPacket->GetSize(),

                          "ReceivedPacket size is not equal to the Rx buffer size");

}


void

Udp6SocketImplTest::ReceivePkt2(Ptr<Socket> socket)

{

    uint32_t availableData [[maybe_unused]] = socket->GetRxAvailable();

    m_receivedPacket2 = socket->Recv(std::numeric_limits<uint32_t>::max(), 0);

    NS_TEST_ASSERT_MSG_EQ(availableData,

                          m_receivedPacket2->GetSize(),

                          "ReceivedPacket size is not equal to the Rx buffer size");

}


void

Udp6SocketImplTest::DoSendDataTo(Ptr<Socket> socket, std::string to)

{

    Address realTo = Inet6SocketAddress(Ipv6Address(to.c_str()), 1234);

    NS_TEST_EXPECT_MSG_EQ(socket->SendTo(Create<Packet>(123), 0, realTo), 123, "200");

}


void

Udp6SocketImplTest::SendDataTo(Ptr<Socket> socket, std::string to)

{

    m_receivedPacket = Create<Packet>();

    m_receivedPacket2 = Create<Packet>();

    Simulator::ScheduleWithContext(socket->GetNode()->GetId(),

                                   Seconds(0),

                                   &Udp6SocketImplTest::DoSendDataTo,

                                   this,

                                   socket,

                                   to);

    Simulator::Run();

}


void

Udp6SocketImplTest::DoRun()

{

    // Create topology


    // Receiver Node

    Ptr<Node> rxNode = CreateObject<Node>();

    // Sender Node

    Ptr<Node> txNode = CreateObject<Node>();


    NodeContainer nodes(rxNode, txNode);


    SimpleNetDeviceHelper helperChannel1;

    helperChannel1.SetNetDevicePointToPointMode(true);

    NetDeviceContainer net1 = helperChannel1.Install(nodes);


    SimpleNetDeviceHelper helperChannel2;

    helperChannel2.SetNetDevicePointToPointMode(true);

    NetDeviceContainer net2 = helperChannel2.Install(nodes);


    InternetStackHelper internetv6;

    internetv6.Install(nodes);


    txNode->GetObject<Icmpv6L4Protocol>()->SetAttribute("DAD", BooleanValue(false));

    rxNode->GetObject<Icmpv6L4Protocol>()->SetAttribute("DAD", BooleanValue(false));


    Ipv6AddressHelper ipv6helper;

    Ipv6InterfaceContainer iic1 = ipv6helper.AssignWithoutAddress(net1);

    Ipv6InterfaceContainer iic2 = ipv6helper.AssignWithoutAddress(net2);


    Ptr<NetDevice> device;

    Ptr<Ipv6> ipv6;

    int32_t ifIndex;

    Ipv6InterfaceAddress ipv6Addr;


    ipv6 = rxNode->GetObject<Ipv6>();

    device = net1.Get(0);

    ifIndex = ipv6->GetInterfaceForDevice(device);

    ipv6Addr = Ipv6InterfaceAddress(Ipv6Address("2001:0100::1"), Ipv6Prefix(64));

    ipv6->AddAddress(ifIndex, ipv6Addr);

    ipv6->SetUp(ifIndex);


    device = net2.Get(0);

    ifIndex = ipv6->GetInterfaceForDevice(device);

    ipv6Addr = Ipv6InterfaceAddress(Ipv6Address("2001:0100:1::1"), Ipv6Prefix(64));

    ipv6->AddAddress(ifIndex, ipv6Addr);

    ipv6->SetUp(ifIndex);


    ipv6 = txNode->GetObject<Ipv6>();

    device = net1.Get(1);

    ifIndex = ipv6->GetInterfaceForDevice(device);

    ipv6Addr = Ipv6InterfaceAddress(Ipv6Address("2001:0100::2"), Ipv6Prefix(64));

    ipv6->AddAddress(ifIndex, ipv6Addr);

    ipv6->SetUp(ifIndex);


    device = net2.Get(1);

    ifIndex = ipv6->GetInterfaceForDevice(device);

    ipv6Addr = Ipv6InterfaceAddress(Ipv6Address("2001:0100:1::2"), Ipv6Prefix(64));

    ipv6->AddAddress(ifIndex, ipv6Addr);

    ipv6->SetUp(ifIndex);


    // Create the UDP sockets

    Ptr<SocketFactory> rxSocketFactory = rxNode->GetObject<UdpSocketFactory>();

    Ptr<Socket> rxSocket = rxSocketFactory->CreateSocket();

    NS_TEST_EXPECT_MSG_EQ(rxSocket->Bind(Inet6SocketAddress(Ipv6Address("2001:0100::1"), 1234)),

                          0,

                          "trivial");

    rxSocket->SetRecvCallback(MakeCallback(&Udp6SocketImplTest::ReceivePkt, this));


    Ptr<Socket> rxSocket2 = rxSocketFactory->CreateSocket();

    rxSocket2->SetRecvCallback(MakeCallback(&Udp6SocketImplTest::ReceivePkt2, this));

    NS_TEST_EXPECT_MSG_EQ(rxSocket2->Bind(Inet6SocketAddress(Ipv6Address("2001:0100:1::1"), 1234)),

                          0,

                          "trivial");


    Ptr<SocketFactory> txSocketFactory = txNode->GetObject<UdpSocketFactory>();

    Ptr<Socket> txSocket = txSocketFactory->CreateSocket();

    txSocket->SetAllowBroadcast(true);

    // ------ Now the tests ------------


    // Unicast test

    SendDataTo(txSocket, "2001:0100::1");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(), 123, "trivial");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket2->GetSize(), 0, "second interface should receive it");


    m_receivedPacket->RemoveAllByteTags();

    m_receivedPacket2->RemoveAllByteTags();


    // Simple Link-local multicast test


    // When receiving broadcast packets, all sockets sockets bound to

    // the address/port should receive a copy of the same packet -- if

    // the socket address matches.

    rxSocket2->Dispose();

    rxSocket2 = rxSocketFactory->CreateSocket();

    rxSocket2->SetRecvCallback(MakeCallback(&Udp6SocketImplTest::ReceivePkt2, this));

    NS_TEST_EXPECT_MSG_EQ(rxSocket2->Bind(Inet6SocketAddress(Ipv6Address("::"), 1234)),

                          0,

                          "trivial");


    txSocket->BindToNetDevice(net1.Get(1));

    SendDataTo(txSocket, "ff02::1");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket->GetSize(),

                          0,

                          "first socket should not receive it (it is bound specifically to the "

                          "second interface's address");

    NS_TEST_EXPECT_MSG_EQ(m_receivedPacket2->GetSize(), 123, "recv2: ff02::1");


    m_receivedPacket->RemoveAllByteTags();

    m_receivedPacket2->RemoveAllByteTags();


    // Simple getpeername tests

    Address peerAddress;

    int err = txSocket->GetPeerName(peerAddress);

    NS_TEST_EXPECT_MSG_EQ(err, -1, "socket GetPeerName() should fail when socket is not connected");

    NS_TEST_EXPECT_MSG_EQ(txSocket->GetErrno(),

                          Socket::ERROR_NOTCONN,

                          "socket error code should be ERROR_NOTCONN");


    Inet6SocketAddress peer("2001:0100::1", 1234);

    err = txSocket->Connect(peer);

    NS_TEST_EXPECT_MSG_EQ(err, 0, "socket Connect() should succeed");


    err = txSocket->GetPeerName(peerAddress);

    NS_TEST_EXPECT_MSG_EQ(err, 0, "socket GetPeerName() should succeed when socket is connected");

    NS_TEST_EXPECT_MSG_EQ(peerAddress,

                          peer,

                          "address from socket GetPeerName() should equal the connected address");


    Simulator::Destroy();

}


class UdpTestSuite : public TestSuite

{

  public:

    UdpTestSuite()

        : TestSuite("udp", UNIT)

    {

        AddTestCase(new UdpSocketImplTest, TestCase::QUICK);

        AddTestCase(new UdpSocketLoopbackTest, TestCase::QUICK);

        AddTestCase(new Udp6SocketImplTest, TestCase::QUICK);

        AddTestCase(new Udp6SocketLoopbackTest, TestCase::QUICK);

    }

};


static UdpTestSuite g_udpTestSuite;

max
#define max(a, b)
Definition: 80211b.c:43

Udp6SocketImplTest
UDP Socket over IPv6 Test.
Definition: udp-test.cc:532

Udp6SocketImplTest::Udp6SocketImplTest
Udp6SocketImplTest()
Definition: udp-test.cc:579

Udp6SocketImplTest::m_receivedPacket
Ptr< Packet > m_receivedPacket
Received packet (1).
Definition: udp-test.cc:533

Udp6SocketImplTest::ReceivePacket
void ReceivePacket(Ptr< Socket > socket, Ptr< Packet > packet, const Address &from)
Receive packets (1).
Definition: udp-test.cc:585

Udp6SocketImplTest::SendDataTo
void SendDataTo(Ptr< Socket > socket, std::string to)
Send data.
Definition: udp-test.cc:624

Udp6SocketImplTest::ReceivePkt2
void ReceivePkt2(Ptr< Socket > socket)
Receive packets (2).
Definition: udp-test.cc:607

Udp6SocketImplTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: udp-test.cc:638

Udp6SocketImplTest::m_receivedPacket2
Ptr< Packet > m_receivedPacket2
Received packet (2).
Definition: udp-test.cc:534

Udp6SocketImplTest::ReceivePkt
void ReceivePkt(Ptr< Socket > socket)
Receive packets (1).
Definition: udp-test.cc:597

Udp6SocketImplTest::ReceivePacket2
void ReceivePacket2(Ptr< Socket > socket, Ptr< Packet > packet, const Address &from)
Receive packets (2).
Definition: udp-test.cc:591

Udp6SocketImplTest::DoSendDataTo
void DoSendDataTo(Ptr< Socket > socket, std::string to)
Send data.
Definition: udp-test.cc:617

Udp6SocketLoopbackTest
UDP Socket Loopback over IPv6 Test.
Definition: udp-test.cc:123

Udp6SocketLoopbackTest::Udp6SocketLoopbackTest
Udp6SocketLoopbackTest()
Definition: udp-test.cc:136

Udp6SocketLoopbackTest::ReceivePkt
void ReceivePkt(Ptr< Socket > socket)
Receive a packet.
Definition: udp-test.cc:142

Udp6SocketLoopbackTest::m_receivedPacket
Ptr< Packet > m_receivedPacket
Received packet.
Definition: udp-test.cc:133

Udp6SocketLoopbackTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: udp-test.cc:152

UdpSocketImplTest
UDP Socket over IPv4 Test.
Definition: udp-test.cc:180

UdpSocketImplTest::UdpSocketImplTest
UdpSocketImplTest()
Definition: udp-test.cc:242

UdpSocketImplTest::GetTos
uint32_t GetTos()
Get the TOS of the received packet.
Definition: udp-test.cc:280

UdpSocketImplTest::GetPriority
uint32_t GetPriority()
Get the priority of the received packet.
Definition: udp-test.cc:286

UdpSocketImplTest::SendData
void SendData(Ptr< Socket > socket)
Send data.
Definition: udp-test.cc:322

UdpSocketImplTest::ReceivePkt2
void ReceivePkt2(Ptr< Socket > socket)
Receive packets (2).
Definition: udp-test.cc:259

UdpSocketImplTest::SendDataTo
void SendDataTo(Ptr< Socket > socket, std::string to)
Send data.
Definition: udp-test.cc:302

UdpSocketImplTest::m_receivedPacket
Ptr< Packet > m_receivedPacket
Received packet (1).
Definition: udp-test.cc:181

UdpSocketImplTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: udp-test.cc:333

UdpSocketImplTest::DoSendData
void DoSendData(Ptr< Socket > socket)
Send data.
Definition: udp-test.cc:316

UdpSocketImplTest::m_sentPacket
Ptr< Ipv4QueueDiscItem > m_sentPacket
Sent packet.
Definition: udp-test.cc:183

UdpSocketImplTest::ReceivePkt
void ReceivePkt(Ptr< Socket > socket)
Receive packets (1).
Definition: udp-test.cc:248

UdpSocketImplTest::SentPkt
void SentPkt(Ptr< const QueueDiscItem > item)
Adds a packet to the list of sent packets.
Definition: udp-test.cc:270

UdpSocketImplTest::m_receivedPacket2
Ptr< Packet > m_receivedPacket2
Received packet (2).
Definition: udp-test.cc:182

UdpSocketImplTest::DoSendDataTo
void DoSendDataTo(Ptr< Socket > socket, std::string to)
Send data.
Definition: udp-test.cc:295

UdpSocketLoopbackTest
UDP Socket Loopback over IPv4 Test.
Definition: udp-test.cc:65

UdpSocketLoopbackTest::m_receivedPacket
Ptr< Packet > m_receivedPacket
Received packet.
Definition: udp-test.cc:75

UdpSocketLoopbackTest::ReceivePkt
void ReceivePkt(Ptr< Socket > socket)
Receive a packet.
Definition: udp-test.cc:84

UdpSocketLoopbackTest::UdpSocketLoopbackTest
UdpSocketLoopbackTest()
Definition: udp-test.cc:78

UdpSocketLoopbackTest::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: udp-test.cc:95

UdpTestSuite
UDP TestSuite.
Definition: udp-test.cc:776

UdpTestSuite::UdpTestSuite
UdpTestSuite()
Definition: udp-test.cc:778

int32_t

ns3::Address
a polymophic address class
Definition: address.h:92

ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37

ns3::Icmpv6L4Protocol
An implementation of the ICMPv6 protocol.
Definition: icmpv6-l4-protocol.h:53

ns3::Inet6SocketAddress
An Inet6 address class.
Definition: inet6-socket-address.h:38

ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:42

ns3::InetSocketAddress::SetTos
void SetTos(uint8_t tos)
Definition: inet-socket-address.cc:106

ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:92

ns3::InternetStackHelper::Install
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Definition: internet-stack-helper.cc:376

ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:43

ns3::Ipv4Header::GetTos
uint8_t GetTos() const
Definition: ipv4-header.cc:196

ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:79

ns3::Ipv4InterfaceAddress
a class to store IPv4 address information on an interface
Definition: ipv4-interface-address.h:45

ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:258

ns3::Ipv4QueueDiscItem::GetHeader
const Ipv4Header & GetHeader() const
Definition: ipv4-queue-disc-item.cc:59

ns3::Ipv6AddressHelper
Helper class to auto-assign global IPv6 unicast addresses.
Definition: ipv6-address-helper.h:84

ns3::Ipv6Address
Describes an IPv6 address.
Definition: ipv6-address.h:50

ns3::Ipv6
Access to the IPv6 forwarding table, interfaces, and configuration.
Definition: ipv6.h:82

ns3::Ipv6InterfaceAddress
IPv6 address associated with an interface.
Definition: ipv6-interface-address.h:37

ns3::Ipv6InterfaceContainer
Keep track of a set of IPv6 interfaces.
Definition: ipv6-interface-container.h:40

ns3::Ipv6Prefix
Describes an IPv6 prefix.
Definition: ipv6-address.h:456

ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43

ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:67

ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40

ns3::Node::GetId
uint32_t GetId() const
Definition: node.cc:117

ns3::ObjectBase::TraceConnectWithoutContext
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:369

ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471

ns3::Object::Dispose
void Dispose()
Dispose of this Object.
Definition: object.cc:219

ns3::Packet::GetSize
uint32_t GetSize() const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:863

ns3::Packet::RemoveAllByteTags
void RemoveAllByteTags()
Remove all byte tags stored in this packet.
Definition: packet.cc:393

ns3::Packet::PeekPacketTag
bool PeekPacketTag(Tag &tag) const
Search a matching tag and call Tag::Deserialize if it is found.
Definition: packet.cc:1002

ns3::Ptr< Socket >

ns3::QueueDiscContainer
Holds a vector of ns3::QueueDisc pointers.
Definition: queue-disc-container.h:46

ns3::QueueDiscContainer::Get
Ptr< QueueDisc > Get(std::size_t i) const
Get the Ptr<QueueDisc> stored in this container at a given index.
Definition: queue-disc-container.cc:53

ns3::QueueItem::GetPacket
Ptr< Packet > GetPacket() const
Definition: queue-item.cc:43

ns3::SimpleNetDeviceHelper
build a set of SimpleNetDevice objects
Definition: simple-net-device-helper.h:38

ns3::SimpleNetDeviceHelper::SetNetDevicePointToPointMode
void SetNetDevicePointToPointMode(bool pointToPointMode)
SimpleNetDevice is Broadcast capable and ARP needing.
Definition: simple-net-device-helper.cc:64

ns3::SimpleNetDeviceHelper::Install
NetDeviceContainer Install(Ptr< Node > node) const
This method creates an ns3::SimpleChannel with the attributes configured by SimpleNetDeviceHelper::Se...
Definition: simple-net-device-helper.cc:76

ns3::Socket::Send
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.

ns3::Socket::GetRxAvailable
virtual uint32_t GetRxAvailable() const =0
Return number of bytes which can be returned from one or multiple calls to Recv.

ns3::Socket::SetRecvCallback
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:126

ns3::Socket::Recv
virtual Ptr< Packet > Recv(uint32_t maxSize, uint32_t flags)=0
Read data from the socket.

ns3::Socket::Bind
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.

ns3::Socket::GetNode
virtual Ptr< Node > GetNode() const =0
Return the node this socket is associated with.

ns3::Socket::SendTo
virtual int SendTo(Ptr< Packet > p, uint32_t flags, const Address &toAddress)=0
Send data to a specified peer.

ns3::SocketPriorityTag
indicates whether the socket has a priority set.
Definition: socket.h:1316

ns3::SocketPriorityTag::GetPriority
uint8_t GetPriority() const
Get the tag's priority.
Definition: socket.cc:858

ns3::TestCase
encapsulates test code
Definition: test.h:1060

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305

ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256

ns3::TestSuite::UNIT
@ UNIT
This test suite implements a Unit Test.
Definition: test.h:1265

ns3::TrafficControlHelper
Build a set of QueueDisc objects.
Definition: traffic-control-helper.h:118

ns3::TrafficControlHelper::Install
QueueDiscContainer Install(NetDeviceContainer c)
Definition: traffic-control-helper.cc:253

ns3::UdpSocketFactory
API to create UDP socket instances.
Definition: udp-socket-factory.h:42

uint32_t

NS_TEST_ASSERT_MSG_EQ
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:144

NS_TEST_EXPECT_MSG_NE
#define NS_TEST_EXPECT_MSG_NE(actual, limit, msg)
Test that an actual and expected (limit) value are not equal and report if not.
Definition: test.h:666

NS_TEST_EXPECT_MSG_EQ
#define NS_TEST_EXPECT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report if not.
Definition: test.h:251

ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338

nodes
NodeContainer nodes
Definition: lr-wpan-bootstrap.cc:50

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::MakeCallback
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...
Definition: callback.h:691

g_udpTestSuite
static UdpTestSuite g_udpTestSuite
Static variable for test initialization.
Definition: udp-test.cc:788