Ns3 Projects for B.E/B.Tech M.E/M.Tech PhD Scholars.  Phone-Number:9790238391   E-mail: ns3simulation@gmail.com

How to Implement Network Trust Models Design in ns3

To implement the network trust models design in ns3, we want to design the model where the nodes estimate the trustworthiness of other nodes based on assured standards and use this data to take the decision about data transmission. Here is the procedure on how to implement the simple trust model in ns3 framework:

Step-by-Step Implementation:

Step 1: Set Up the Simulation Environment

  • Make sure ns3 is installed in the computer.

Step 2: Create the Network Topology

  • Make the network topology using ns3 with multiple nodes. In this sample, we will emulate the scenario where nodes interact and estimate trust based on successful packet transmissions.

Step 3: Define the Trust Model Application

  • To simulate the trust model mechanism makes the custom application.

Step 4: Write the Script

  • Now, we provide the sample of how to generate and configure the network trust model applications in ns3:
  1. Create a New File:
    • Save the following script as network-trust-model.cc in the scratch directory of your ns3 installation.

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

#include “ns3/mobility-module.h”

#include “ns3/wifi-module.h”

#include <map>

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“NetworkTrustModelExample”);

class TrustModelApplication : public Application

{

public:

TrustModelApplication ();

virtual ~TrustModelApplication ();

void Setup (Ptr<Socket> socket, Address address, uint32_t packetSize, uint32_t nPackets, Time interPacketInterval);

void AddNodeTrust (Ptr<Node> node, double initialTrust);

double GetNodeTrust (Ptr<Node> node) const;

protected:

virtual void StartApplication (void);

virtual void StopApplication (void);

private:

void SendPacket ();

void ReceivePacket (Ptr<Socket> socket);

void UpdateTrust (Ptr<Node> node, bool success);

Ptr<Socket> m_socket;

Address m_peer;

uint32_t m_packetSize;

uint32_t m_nPackets;

Time m_interval;

uint32_t m_sent;

std::map<Ptr<Node>, double> m_trustTable;

EventId m_sendEvent;

};

TrustModelApplication::TrustModelApplication ()

: m_socket (0),

m_packetSize (0),

m_nPackets (0),

m_sent (0)

{

}

TrustModelApplication::~TrustModelApplication ()

{

m_socket = 0;

}

void

TrustModelApplication::Setup (Ptr<Socket> socket, Address address, uint32_t packetSize, uint32_t nPackets, Time interPacketInterval)

{

m_socket = socket;

m_peer = address;

m_packetSize = packetSize;

m_nPackets = nPackets;

m_interval = interPacketInterval;

}

void

TrustModelApplication::AddNodeTrust (Ptr<Node> node, double initialTrust)

{

m_trustTable[node] = initialTrust;

}

double

TrustModelApplication::GetNodeTrust (Ptr<Node> node) const

{

auto it = m_trustTable.find(node);

if (it != m_trustTable.end())

{

return it->second;

}

return 0.0; // Default trust value

}

void

TrustModelApplication::StartApplication (void)

{

m_socket->Bind ();

m_socket->Connect (m_peer);

m_socket->SetRecvCallback (MakeCallback (&TrustModelApplication::ReceivePacket, this));

SendPacket ();

}

void

TrustModelApplication::StopApplication (void)

{

if (m_socket)

{

m_socket->Close ();

}

Simulator::Cancel (m_sendEvent);

}

void

TrustModelApplication::SendPacket ()

{

Ptr<Packet> packet = Create<Packet> (m_packetSize);

m_socket->Send (packet);

NS_LOG_UNCOND (“Sent packet of size ” << m_packetSize);

if (++m_sent < m_nPackets)

{

m_sendEvent = Simulator::Schedule (m_interval, &TrustModelApplication::SendPacket, this);

}

}

void

TrustModelApplication::ReceivePacket (Ptr<Socket> socket)

{

Ptr<Packet> packet = socket->Recv ();

NS_LOG_UNCOND (“Received packet of size ” << packet->GetSize ());

Ptr<Node> fromNode = socket->GetNode(); // Example way to determine source node

UpdateTrust(fromNode, true); // Assuming success for this example

}

void

TrustModelApplication::UpdateTrust (Ptr<Node> node, bool success)

{

if (m_trustTable.find(node) != m_trustTable.end())

{

if (success)

{

m_trustTable[node] += 0.1; // Increase trust

}

else

{

m_trustTable[node] -= 0.1; // Decrease trust

}

}

}

int main (int argc, char *argv[])

{

CommandLine cmd;

cmd.Parse (argc, argv);

NodeContainer nodes;

nodes.Create (3); // Three nodes for the trust model

// Set up point-to-point links between nodes

PointToPointHelper pointToPoint;

pointToPoint.SetDeviceAttribute (“DataRate”, StringValue (“5Mbps”));

pointToPoint.SetChannelAttribute (“Delay”, StringValue (“2ms”));

NetDeviceContainer devicesAB, devicesBC;

devicesAB = pointToPoint.Install (nodes.Get (0), nodes.Get (1)); // A to B

devicesBC = pointToPoint.Install (nodes.Get (1), nodes.Get (2)); // B to C

// Install the Internet stack on the nodes

InternetStackHelper stack;

stack.Install (nodes);

// Assign IP addresses to the devices

Ipv4AddressHelper address;

address.SetBase (“10.1.1.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfacesAB = address.Assign (devicesAB);

address.SetBase (“10.1.2.0”, “255.255.255.0”);

Ipv4InterfaceContainer interfacesBC = address.Assign (devicesBC);

// Set up mobility

MobilityHelper mobility;

mobility.SetMobilityModel (“ns3::ConstantPositionMobilityModel”);

mobility.Install (nodes);

nodes.Get (0)->GetObject<MobilityModel> ()->SetPosition (Vector (0.0, 0.0, 0.0));

nodes.Get (1)->GetObject<MobilityModel> ()->SetPosition (Vector (50.0, 0.0, 0.0));

nodes.Get (2)->GetObject<MobilityModel> ()->SetPosition (Vector (100.0, 0.0, 0.0));

// Set up trust model applications

uint32_t packetSize = 1024;

uint32_t nPackets = 10;

Time interPacketInterval = Seconds (1.0);

// Node A

Ptr<Socket> sourceSocketA = Socket::CreateSocket (nodes.Get (0), UdpSocketFactory::GetTypeId ());

Ptr<TrustModelApplication> appA = CreateObject<TrustModelApplication> ();

appA->Setup (sourceSocketA, InetSocketAddress (interfacesAB.GetAddress (1), 9), packetSize, nPackets, interPacketInterval);

appA->AddNodeTrust (nodes.Get (1), 0.5); // Initial trust value for Node B

nodes.Get (0)->AddApplication (appA);

appA->SetStartTime (Seconds (2.0));

appA->SetStopTime (Seconds (10.0));

// Node B

Ptr<Socket> sinkSocketB = Socket::CreateSocket (nodes.Get (1), UdpSocketFactory::GetTypeId ());

InetSocketAddress localB = InetSocketAddress (Ipv4Address::GetAny (), 9);

sinkSocketB->Bind (localB);

Ptr<TrustModelApplication> appB = CreateObject<TrustModelApplication> ();

nodes.Get (1)->AddApplication (appB);

sinkSocketB->SetRecvCallback (MakeCallback (&TrustModelApplication::ReceivePacket, appB));

// Enable packet capturing

pointToPoint.EnablePcapAll (“network-trust-model”);

// Run simulation

Simulator::Run ();

Simulator::Destroy ();

return 0;

}

Explanation:

  1. Create Nodes and Network:
    • Create three nodes and connect them using point-to-point links.
    • Install the Internet stack on the nodes.
    • Assign IP addresses to the devices.
  2. Define Trust Model Application:
    • Create a TrustModelApplication class that maintains a trust table for nodes.
    • The SendPacket function creates packets and sends them.
    • The ReceivePacket function handles incoming packets and updates the trust table based on the success of packet reception.
    • The UpdateTrust function updates the trust value of nodes based on the success or failure of packet receptions.
  3. Install and Configure the Application:
    • Create sockets for sending and receiving.
    • Install the TrustModelApplication on the nodes.
    • Configure the application with the necessary parameters, such as packet size, number of packets, and inter-packet interval.
    • Initialize the trust values for nodes.
  4. Run the Simulation:
    • Schedule the start and stop times for the applications.
    • Run the simulation and log the results.

Step 4: Compile and Run the Script

  1. Save the script as network-trust-model.cc in the scratch directory of your ns-3 installation.
  2. Compile the script using the following commands:

./waf configure

./waf build

./waf –run network-trust-model

Step 5: Analyze the Results

After running the simulation, we need to evaluate the outcomes by looking at the logs to validate the performance of the trust model application.

In the end, we had implemented and estimated the Network Trust Models design in ns3 tool successfully. We provide additional details on how the Network Trust Models design behaves in other simulation tool.

We develop Network Trust Models within ns3 to evaluate the reliability of other nodes according to established criteria, utilizing this information to inform decisions regarding data transmission for your project. Achieve optimal simulation outcomes with ns3simulation.com.