ATHARVA KALE PRACTICAL NO.

7 ROLL NO: 27

AIM: Program to simulate DHCP server and n clients.

 THEORY:
1. The Dynamic Host Configuration Protocol (DHCP) is a network management
protocol used on Internet Protocol (IP) networks for automatically assigning IP
addresses and other communication parameters to devices connected to the
network using a client–server architecture.
2. The technology eliminates the need for individually configuring network devices
manually, and consists of two network components, a centrally installed network
DHCP server and client instances of the protocol stack on each computer or
device.
3. When connected to the network, and periodically thereafter, a client requests a
set of parameters from the DHCP server using the DHCP protocol.
4. Working:
a. DHCP works by leasing IP addresses and IP information to network clients
for a period of time. For the lease to happen, the following negotiation
process occurs:
b. During the boot process, a client computer that is configured as a DHCP
client sends out a broadcast packet called DHCPDISCOVER. This Discover
packet contains the client’s computer name and Media Access Control
(MAC) address so the DHCP servers can respond to it.
c. DHCP servers on the network respond to the broadcast with a
DHCPOFFER. If several DHCP servers respond to the request, the client
accepts the first offer that it receives.
d. The client responds via a broadcast message called a DHCPREQUEST. If
other DHCP servers made offers, they also see their lease offers were not
accepted by the broadcast message, so they rescind their offers.
e. The DHCP server whose offer was accepted responds with a DHCPACK
message, which acknowledges the lease acceptance and contains the
ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

client’s IP address lease as well as other IP addressing information that

you configure the server to provide. The client is now a TCP/IP client and
can participate on the network.
5. Classes Used In Code:
a. Following different classes are used in code:
i. Node Class:
1. In ns-3 the basic computing device abstraction is called the
node. This abstraction is represented in C++ by the class
Node.
2. The Node class provides methods for managing the
representations of computing devices in simulations.
ii. PointToPointHelper Class:
1. PointToPointNetDevice class specializes the NetDevice
abstract base class.
2. Together with a PointToPointChannel 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.
iii. DhcpHelper Class:
1. The helper class used to configure and install DHCP
applications on nodes.
iv. NetDevice Class:
1. Net device abstraction covers both the software driver and
the simulated hardware. The net device abstraction is
represented in C++ by the class NetDevice.
2. The NetDevice class provides methods for managing
connections to Node and Channel objects; and may be
ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

specialized by developers in the object-oriented

programming sense.

A) Write a program to simulate DHCP server and n clients.

 CODE:
#include "ns3/core-module.h"
#include "ns3/internet-apps-module.h"
#include "ns3/csma-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"
#include "ns3/netanim-module.h"
using namespace ns3;
NS_LOG_COMPONENT_DEFINE ("DhcpExample");
Int main (int argc, char *argv[])
{
CommandLine cmd (__FILE__);

bool verbose = false;

bool tracing = false;
cmd.AddValue ("verbose", "turn on the logs", verbose);
cmd.AddValue ("tracing", "turn on the tracing", tracing);
cmd.Parse (argc, argv);
// GlobalValue::Bind ("ChecksumEnabled", BooleanValue (true));
if (verbose)
{
LogComponentEnable ("DhcpServer", LOG_LEVEL_ALL);
LogComponentEnable ("DhcpClient", LOG_LEVEL_ALL);
LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);
ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);

}
Time stopTime = Seconds (20);
NS_LOG_INFO ("Create nodes.");
NodeContainer nodes;
NodeContainer router;
nodes.Create (3);
router.Create (2);

NodeContainer net (nodes, router);

NS_LOG_INFO ("Create channels.");

CsmaHelper csma;
csma.SetChannelAttribute ("DataRate", StringValue ("5Mbps"));
csma.SetChannelAttribute ("Delay", StringValue ("2ms"));
csma.SetDeviceAttribute ("Mtu", UintegerValue (1500));
NetDeviceContainer devNet = csma.Install (net);

NodeContainer p2pNodes;
p2pNodes.Add (net.Get (4));
p2pNodes.Create (1);

PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

NetDeviceContainer p2pDevices;
p2pDevices = pointToPoint.Install (p2pNodes);
ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

InternetStackHelper tcpip;
tcpip.Install (nodes);
tcpip.Install (router);
tcpip.Install (p2pNodes.Get (1));

Ipv4AddressHelper address;
address.SetBase ("172.30.1.0", "255.255.255.0");
Ipv4InterfaceContainer p2pInterfaces;
p2pInterfaces = address.Assign (p2pDevices);

// manually add a routing entry because we don't want to add a dynamic routing
Ipv4StaticRoutingHelper ipv4RoutingHelper;
Ptr<Ipv4> ipv4Ptr = p2pNodes.Get (1)->GetObject<Ipv4> ();
Ptr<Ipv4StaticRouting> staticRoutingA = ipv4RoutingHelper.GetStaticRouting (ipv4Ptr);
staticRoutingA->AddNetworkRouteTo (Ipv4Address ("172.30.0.0"), Ipv4Mask ("/24"),
Ipv4Address ("172.30.1.1"), 1);

NS_LOG_INFO ("Setup the IP addresses and create DHCP applications.");

DhcpHelper dhcpHelper;

// The router must have a fixed IP.

Ipv4InterfaceContainer fixedNodes = dhcpHelper.InstallFixedAddress (devNet.Get (4),
Ipv4Address ("172.30.0.17"), Ipv4Mask ("/24"));
// Not really necessary, IP forwarding is enabled by default in IPv4.
fixedNodes.Get (0).first->SetAttribute ("IpForward", BooleanValue (true));

// DHCP server
ApplicationContainer dhcpServerApp = dhcpHelper.InstallDhcpServer (devNet.Get (3),
Ipv4Address ("172.30.0.12"),
ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

Ipv4Address ("172.30.0.0"), Ipv4Mask ("/24"),

Ipv4Address ("172.30.0.10"), Ipv4Address
("172.30.0.15"),
Ipv4Address ("172.30.0.17"));

// This is just to show how it can be done.

DynamicCast<DhcpServer> (dhcpServerApp.Get (0))->AddStaticDhcpEntry (devNet.Get
(2)->GetAddress (), Ipv4Address ("172.30.0.14"));

dhcpServerApp.Start (Seconds (0.0));

dhcpServerApp.Stop (stopTime);

// DHCP clients
NetDeviceContainer dhcpClientNetDevs;
dhcpClientNetDevs.Add (devNet.Get (0));
dhcpClientNetDevs.Add (devNet.Get (1));
dhcpClientNetDevs.Add (devNet.Get (2));

ApplicationContainer dhcpClients = dhcpHelper.InstallDhcpClient (dhcpClientNetDevs);

dhcpClients.Start (Seconds (1.0));
dhcpClients.Stop (stopTime);

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (p2pNodes.Get (1));

serverApps.Start (Seconds (0.0));
serverApps.Stop (stopTime);

UdpEchoClientHelper echoClient (p2pInterfaces.GetAddress (1), 9);

ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

echoClient.SetAttribute ("MaxPackets", UintegerValue (100));

echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps = echoClient.Install (nodes.Get (1));

clientApps.Start (Seconds (10.0));
clientApps.Stop (stopTime);

Simulator::Stop (stopTime + Seconds (10.0));

if (tracing)
{
csma.EnablePcapAll ("dhcp-csma");
pointToPoint.EnablePcapAll ("dhcp-p2p");
}

AnimationInterface anim("dhcp.xml");
NS_LOG_INFO ("Run Simulation.");
Simulator::Run ();
Simulator::Destroy ();
NS_LOG_INFO ("Done.");
}
ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

 OUTPUT:
o ./waf Output:

o Python Visualizer:
ATHARVA KALE PRACTICAL NO. 7 ROLL NO: 27

o NetAnim Output:

 CONCLUSION:
Hence we successfully simulated DHCP server and n clients.