Documente Academic
Documente Profesional
Documente Cultură
CS6411
NETWORKS LABORATORY
LTPC
0032
OBJECTIVES:
The student should be made to:
Learn socket programming.
Be familiar with simulation tools.
Have hands on experience on various networking protocols.
LIST OF EXPERIMENTS:
1. Implementation of Stop and Wait Protocol and Sliding Window Protocol.
2. Study of Socket Programming and Client Server model
3. Write a code simulating ARP /RARP protocols.
4. Write a code simulating PING and TRACEROUTE commands
5. Create a socket for HTTP for web page upload and download.
6. Write a program to implement RPC (Remote Procedure Call)
7. Implementation of Subnetting .
8. Applications using TCP Sockets like
a. Echo client and echo server
b. Chat
c. File Transfer
9. Applications using TCP and UDP Sockets like
d. DNS
e. SNMP
f. File Transfer
10. Study of Network simulator (NS) and Simulation of Congestion Control Algorithms using NS
11. Perform a case study about the different routing algorithms to select the network path with
its optimum and economical during data transfer.
i. Link State routing
ii. Flooding
iii. Distance vector
TOTAL: 45 PERIODS
REFERENCE:
spoken-tutorial.org.
OUTCOMES:
At the end of the course, the student should be able to
Use simulation tools
Implement the various protocols.
Analyse the performance of the protocols in different layers.
Analyze various routing algorithms
LIST OF EXPERIMENTS
S.no
Chat
File Transfer
DNS
SNMP
File Transfer
5a
5b
Implementation of RPC
7a
7b
Socket Programming for Web page Upload and Download using HTTP
10
Implementation of Subnetting
11a
11b
12
Flooding
Distance Vector
Content beyond syllabus
13
14
EX NO 1
Aim:
To study the basic networking commands
Ping
ping sends an ICMP ECHO_REQUEST packet to the specified host. If the host responds,
we get an ICMP packet back. We can ping an IP address to see if a machine is alive. If there is
no response, we know something is wrong.
ping, a very useful day-to-day command. It provides a very quick way to see if a machine
is up and connected to the network. The basic syntax is:
Example:
Z:\> ping cse
pathping
Provides information about network latency and network loss at intermediate hops
between a source and destination. pathping sends multiple Echo Request messages to each router
between a source and destination over a period of time and then computes results based on the
packets returned from each router.
Example:
Z:\>pathping www.yahoo.com
Trace complete
nslookup
The nslookup command can be used in Windows and Unix to find various details relating
to the Domain Name System (DNS) like IP addresses of a particular computer.nslookup comes
with a number of subcommands to help us to get more information from the specific dns servers.
Example:
server NAME (where NAME is the name or ip address of the dns server we wish to
query). It is not always possible to query a specific dns server as often dns queries are
blocked to prevent denial of service attacks.
Using subcommands:
Z:\>nslookup 204.228.150.3
Server: eec.ac.in
Address: 10.1.1.2
Name:
www.computerhope.com
Address: 204.228.150.3
The first two lines are information about the server delivering the answer to the nslookup
requested by the user. The next two lines tell the user the name and IP address of the machine
being looked up.
arp
When we need an Ethernet (MAC) address we can use arp (address resolution protocol).In
other words it shows the physical address of a host.
6
Example:
Z:\>arp -a
Interface: 10.2.1.205 --- 0x10003
Internet Address
Physical Address
Type
10.1.1.2
00-04-23-dc-dd-d4
dynamic
10.1.1.4
00-15-17-53-53-59
dynamic
10.1.1.5
00-02-b3-50-69-18
dynamic
10.2.1.201
00-16-76-87-01-0d
dynamic
netstat
The netstat command is used to display the TCP/IP network protocol statistics and
information (Shows network status).The netstat command symbolically displays the contents of
various network-related data structures for active connections.
The default display for active sockets shows the following items:
Local and remote addresses
Send and receive queue sizes (in bytes)
Protocol
Internal state of the protocol
Example:
Z:\>netstat
Active Connections
Proto Local Address
Foreign Address
State
TCP
EEC0205:1045
proxy.eec.ac.in:3128
ESTABLISHED
TCP
EEC0205:1068
eec.ac.in:microsoft-ds
ESTABLISHED
TCP
EEC0205:1074
proxy.eec.ac.in:3128
CLOSE_WAIT
TCP
EEC0205:1525
eec.ac.in:microsoft-ds
TIME_WAIT
TCP
EEC0205:1047
localhost:1048
ESTABLISHED
ipconfig
ipconfig (internet protocol configuration) is a DOS utility which can be used from MSDOS and a MS-DOS shell to display the network settings currently assigned and given by a
network. This command can be utilized to verify a network connection as well as to verify your
network settings.
Example:
Z:\>ipconfig
Windows IP Configuration
Ethernet adapter Local Area Connection:
Connection-specific DNS Suffix : eec.ac.in
IP Address. . . . . . . . . . . . : 10.2.1.205
Subnet Mask . . . . . . . . . . . : 255.0.0.0
Default Gateway . . . . . . . . . : 10.1.1.4
hostname
Tells the user the host name of the computer they are logged into. Note: may be called host.
Example:
Z:\>hostname
EEC0205
dig(Try using Linux)
The "domain information groper" tool. More advanced then host... If you give a
hostname as an argument to output information about that host, including it's IP address,
hostname and various other information.To look up information about www.yahoo.com:
Example:
[vijay@linux ~]$ dig www.yahoo.com
tracert
traceroute will show the route of a packet. It attempts to list the series of hosts through
which your packets travel on their way to a given destination.
Example:
Z:\>tracert
Usage: tracert [-d] [-h maximum_hops] [-j host-list] [-w timeout] target_name
Options:
-d
-j host-list
Z:\>tracert www.yahoo.com
Tracing route to www-real.wa1.b.yahoo.com [209.131.36.158]
over a maximum of 30 hops:
1
<1 ms
<1 ms
<1 ms
<1 ms
6 ms
7 ms
4 ms 121.240.156.78.static-chennai.vsnl.net.in [121.240.156.78]
54 ms
18 ms
26 ms 202.54.65.86
Easily and quickly identify the size of files/programs in certain directories. A word of caution is
that you should not run this command from the / directory. It will actually display size for every
file on the entire Linux harddisk.
find
Find locations of files/directories quickly across entire filesystem
Most common use: find / -name appname -type d -xdev
ps
Lists all existing processes on the server
Most common uses: ps and also ps -A |more
top
Displays many system statistics and details regarding active processes
Most common use: top
traceroute
Traces the existing network routing for a remote or local server
Most common use: traceroute hostname
(replace hostname with the name of your server such as reallylinux.com)
w
An extension of the who command that displays details of all users currently on the
server
Most common uses: w
who
Tool used to monitor who is on the system and many other server related
characteristics
Most common uses: who and also who -q and also who -b
The plain command just lists the names of users currently on the server. Using the -q option
allows you to quickly view just the total number of users on the system. Using the -b option
reminds you how long it has been since you rebooted that stable Linux server! One of my
servers had a -b of almost three years! Yes, that's really Linux!
Result:
Thus the basic Networking Commands are studied.
10
EX NO 2
Aim:
To study about the basics of Socket in Network Programming
Network Programming
Network programming involves writing programs that communicate with other programs
across a computer N/W. One program is normally called the client, and the other the server.
Common examples in the TCP/IP are web clients (browsers) & Web Servers, FTP clients & server
and Telnet clients & servers.
To facilitate communication between unrelated processes, and to standardize network
programming, an API is needed. There are two such APIs:
1. Sockets, sometimes called Berkeley Sockets
2. XTI (X/open transport interface)
Socket
In TCP/IP, an addressable point that consists of an IP address and a TCP or UDP port
member that provides application with access to TCP/IP protocol is called Socket.
A socket is an abstraction that represents an endpoint of communication. The operations
that can be performed on a socket include control operations (such as associating a port number
with the socket, initiating or accepting a connection on the socket, or destroying the socket), data
transfer operations (such as writing data through the socket to some other application, or reading
data from some other application through the socket) and status operations (such as finding the IP
address associated with the socket). The complete set of operations that can be performed on a
socket constitutes the Sockets API (Application Programming Interface).
Structures
Structures are used in socket programming to hold information about the address. The
generic socket address structure is defined below:
struct sockaddr
{
unsigned short sa_family;
/* address family */
char sa_data[14];
/* 14 bytes of protocol address*/
};
IPv4 Socket Address Structure
This structure is also called as Internet socket address structure. It is defined by
including the <netinet/in.h> header.
struct in_addr {
in_addr_t
s_addr;
/* 32-bit IPv4 address, network byte ordered */
};
struct sockaddr_in{
unit_t sin_len;
/* length of structure (16 byte) */
sa_family_t sin_family; /*AF_INET*/
in_port_t
sin_port;
/* 16-bit TCP or UDP port number */
/* network byte ordered */
struct in_addr sin_addr;
/*32-bit Ipv4 address, network byte ordered */
char
sin_zero[8]; /* unused initialize to all zeroes */
};
11
Important functions
1.socket()
This function is called by both TCP server and client process to create an empty socket.
#include <sys/socket.h>
int socket (int family, int type, int protocol);
family: specifies the protocol family and is one of the constants below:
Family
description
AF_INET
IPv4 protocols
AF_INET6
IPv6 protocols
AF_LOCAL
AF_ROUTE
Routing sockets
AF_KEY
Key sockets
4. listen()
The listen function is called only by a TCP server to converts an unconnected socket into a
passive socket, indicating that kernel should accept incoming connection requests directed to its
socket.
#include<sys/socket.h>
int listen (int sockfd, int backlog);
sockfd: a socket descriptor returned by the socket function.
backlog: maximum number of connections that the kernel should queue for this socket.
Returns on success: 0, on error: -1
5. accept()
The accept function is called by the TCP server to return the next completed connection from the
front of the completed connection queue.
#include<sys/socket.h>
int accept (int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);
sockfd: This is the same socket descriptor as in listen call.
*cliaddr: used to return the protocol address of the connected peer process
*addrlen: length of the address.
Returns on success: a new (connected)socket descriptor, on error:-1
6. close()
The close function is used to close a socket and terminate a TCP connection.
#include <unistd.h>
int close (int sockfd);
sockfd: This socket descriptor is no longer useable.
Returns on success: 0, on error: -1
7. read()
The read function is used to receive data from the specified socket.
#include <unistd.h>
ssize_t read(int sockfd, const void * buf, size_t nbytes);
sockfd: a socket descriptor returned by the socket function.
buf: buffer to store the data.
nbytes: size of the buffer
Returns: number of bytes read if OK,0 on EOF, -1 on error
8. write()
The write function is used to send the data through the specified socket.
#include <unistd.h>
ssize_t write(int sockfd, const void * buf, size_t nbytes);
sockfd: a socket descriptor returned by the socket function.
buf: buffer to store the data.
nbytes: size of the buffer
Returns: number of bytes written if OK,0 on EOF, -1 on error
13
9. sendto()
This function is similar to the write function, but additional arguments are required.
#include<sys/socket.h>
ssize_t sendto(int sockfd, const void *buff, size_t nbyte, int flag,
const struct sockaddr *to, socklen_t addrlen);
sockfd socket descriptor
*buff pointer to buffer to write from.
nbytes number of bytes to write.
to socket address structure containing the protocol address of where the data is to be sent.
addrlen size of the socket address structure
Returns: number of bytes read or written if OK,-1 on error
10. recvfrom()
This function is similar to the read function, but additional arguments are required.
#include<sys/socket.h>
ssize_t recvfrom(int sockfd, void *buff, size_t nbyte, int flag,
struct sockaddr *from, socklen_t *addrlen);
sockfd socket descriptor
*buff pointer to buffer to read.
nbytes number of bytes to read.
addrlen size of the socket address structure
from - socket address structure of who sent the datagram.
Returns: number of bytes read or written if OK,-1 on error
14
bind()
listen()
accept()
TCP Client
socket()
Connection
establishment
conect()
data ( request)
write()
read()
read()
process request
data ( reply)
write()
close()
EOF notification
read()
close()
15
bind()
UDP Client
socket()
sendto()
recvfrom()
Data (request)
Data (reply)
recvfrom()
sendto()
close()
/* file descriptors */
int sin_size;
int x;
if ((fd=socket(AF_INET, SOCK_STREAM, 0)) == -1 ){ /* calls socket() */
printf("socket() error\n");
exit(-1);
}
server.sin_family = AF_INET;
server.sin_port = htons(PORT);
/* Remember htons() from "Conversions" section? =) */
server.sin_addr.s_addr = INADDR_ANY; /* INADDR_ANY puts your IP address
automatically */
bzero(&(server.sin_zero),8);
/* zero the rest of the structure */
if(bind(fd,(struct sockaddr*)&server,sizeof(struct sockaddr))==-1) /* calls bind() */
{
printf("bind() error\n");
exit(-1);
}
x=listen(fd,BACKLOG) ;
/* calls listen() */
if(x==-1)
{
printf("listen() error\n");
exit(-1);
}
else
{
printf(Server is in listening mode \n );
}
close(fd);
/* close fd */
}
/* file descriptors */
int sin_size;
if ((fd=socket(AF_INET, SOCK_STREAM, 0)) == -1 ) /* calls socket() */
{
printf("socket() error\n");
exit(-1);
}
server.sin_family = AF_INET;
server.sin_port = htons(PORT);
/* Remember htons() from "Conversions" section */
server.sin_addr.s_addr = INADDR_ANY; /* INADDR_ANY puts your IP address
automatically */
bzero(&(server.sin_zero),8);
/* zero the rest of the structure */
if(bind(fd,(struct sockaddr*)&server,sizeof(struct sockaddr))==-1){ /* calls bind() */
printf("bind() error\n");
exit(-1);
}
if(listen(fd,BACKLOG) == -1)
/* calls listen() */
{
printf("listen() error\n");
exit(-1);
}
printf("server is in accept mode \n ");
while(1)
{
sin_size=sizeof(struct sockaddr_in);
if ((fd2 = accept(fd,(struct sockaddr *)&client,&sin_size))==-1){ /* calls accept() */
printf("accept() error\n");
exit(-1);
}
else
printf(" Server is in accept mode ");
printf("You got a connection from %s\n",inet_ntoa(client.sin_addr) ); /* prints client's IP */
close(fd2); /* close fd2 */
}
}
Result:
Thus the basics of socket with example peograms are studied.
19
EX NO 3a
Aim
To write a program in C to implement TCP Echo Client Server .
Algorithm
Server
1. A TCP socket is created.
2. An Internet socket address structure is filled in with the wildcard address
(INADDR_ANY) and the servers well-known port (PORT).
3. The socket is converted into a listening socket by calling the listen function.
4. The server blocks in the call to accept, waiting for the client connection to complete.
5. When the connection is established, the server reads the line from the client using
readn and echoes it back to the client using writen.
6. Finally, the server closes the connected socket.
Client:
1. A TCP socket is created.
2. An Internet socket address structure is filled in with the servers IP address and the
same port number.
3. The connect function establishes the connection with the server.
4. The client reads a line of text from the standard input using fgets, writes it to the server
using writen, reads back the servers echo of the line using readline and outputs the
echoed line to the standard output using fputs.
OUTPUT:
//SERVER
$ cc iterserv.c
$ ./a.out
Message Received and Echoed : Good
//CLIENT
$ cc itercli.c
$ ./a.out 127.0.0.1
ENTER THE STRING TO ECHO :Good
Good
$
Result:
Thus the implementation of TCP Echo Client Server using C Program is executed and the
output is verified successfully.
20
Ex No : 3b
Aim
To perform the full duplex chat by sending and receiving the message from the client to server
and vice versa using TCP sockets.
Algorithm
Server
1. A TCP socket is created.
2. An Internet socket address structure is filled in with the wildcard address
(INADDR_ANY) and the servers well-known port (PORT).
3. The socket is converted into a listening socket by calling the listen function.
4. The server blocks in the call to accept, waiting for the client connection to complete.
5. When the connection is established, the server reads the line from the client using
connected socket and display the message in the standard output using fputs.
6. Then again the server reads a line of text from the standard input and writes it back to
the client through the connected socket.
7. The server went through the steps (5) and (6) until it receives 'bye' either from the
standard input or client.
8. Finally, the server closes the connected socket.
Client:
1. A TCP socket is created.
2. An Internet socket address structure is filled in with the servers IP address and the
same port number.
3. The connect function establishes the connection with the server.
4. When the connection is established, the client reads the line from the standard input
using fgets and send the message to the server through the socket.
5. Then again the client reads a line of text from the server through the connected socket
and writes it back to the standard output using fputs.
6. The client went through the steps (4) and (5) until it receives 'bye' either from the
standard input or server.
7. Finally, the client closes the connected socket.
OUTPUT
//Server
$ cd ..
$ cd TCPCHAT
$ cc tcpchatser.c
$ ./a.out
Server Socket Created Successfully.
Server Socket Binded.
Server Socket Listened...
From client :Hello
Server :Hi ..How are you?
From client :Fine. How Are You?
Server :Fine
From client :Bye
Server :bye
21
//Client
$ cc tcpchatcli.c
$ ./a.out 127.0.0.1
Client Socket Created Successfully.
Client Socket with Server Successfully.
Client. :Hello
From Server :Hi ..How are you?
Client. :Fine. How Are You?
From Server :Fine
Client. :Bye
From Server :bye
$
Result:
Thus the full duplex chat by sending and receiving the message from the client to server
and vice versa using TCP socket is executed and the output is verified successfully.
22
EX NO 3c
FILE TRANSFER
Aim:
To write a program for File Transfer Application using TCP socket.
Algorithm:
Server:
Step 1: Start
Step 2: Create a socket with address family AF_INET, type SOCK_STERAM and default
protocol.
Step 3: Initialize the socket and set its attributes.
Step 4: Bind the server to socket using bind function.
Step 5: wait for the client request on request establish a connection using accept() function.
Step 6: Read the source and destination files names from the client.
Step 7: Open the source and destination files.
Step 8: Read one line of source file and send it to client.
Step 9: Receive the line back from the client.
Step 10: Repeat steps 8&9 until the end of the source file.
Step 11: close the source and destination files.
Step 12: close the connection and goto step5.
Client:
Step 1: start
Step 2: Create a socket with address family AEINET type SOCK_STREAM and default protocol.
Step 3: Initialize the socket and set its attribute set required port no.
Step 4: Connect to server using connect () function to initiate the request.
Step 5: send the source and destination file names to server.
Step 6: Recive the string from the server and print it at the console.
Step 7: send the string to the server.
Step 8: Repeat step6&7 until the server terminates and connection.
Step 9: stop.
SAMPLE INPUT OUTPUT:
Server Side:
[cseb17@localhost cseb 17]$ cc trj3server.c
[cseb17@localhost cseb 17]$.a/out
Client requesting
Received:new.c
Stored in : thanga.c
Client side:
[cseb17@localhost cseb 17]$cc trj3client.c
[cseb17@localhost cseb 17]$./a.out 127.0.0.1 6142 new.c.thanga.c
connected...sending filename new.c
hai how are you?
Result:
Thus the C program for File Transfer Application using TCP socket is executed and the
output is verified successfully
23
EX NO 4a
Aim
To write a program in C to simulate the Domain Name System.
Algorithm
Server
1. A TCP socket is created.
2. An Internet socket address structure is filled in with the wildcard address
(INADDR_ANY) and the servers well-known port (PORT).
3. The socket is converted into a listening socket by calling the listen function.
4. The server blocks in the call to accept, waiting for the client connection to complete.
5. When the connection is established, the server reads the domain name from the client
using readn.
6. It then finds out the corresponding address using gethostbyname() and sends it back to the
client using writen.
24
4. The add_mibdir() and read_mib() functions demonstrated how to add a directory to the
internal MIB path and then read a MIB into the MIB tree.
5. Now that the session is open and the MIBs we'll use are loaded into the tree we can
create and populate the PDU(s) we'll be sending.
6. snmp_pdu_create() will setup the base PDU information based on the supplied type of
PDU (specified in macro form) and return the populated PDU structure.
7.
Now
that
we
have
the
PDU
we
can
use
the read_objid() and snmp_add_null_var() functions to first read the OID from the MIB
and then add that OID as a variable to the variable list used by the PDU.
8. We can repeat this process several times to continue packing our PDU full of OIDs.
9. Once our session is open and our PDU is ready with all the OIDs we want crammed
into the variable list we can actually send the request and await the response. This action is
done in a single step using thesnmp_synch_response() function.
10. The function is passed the open session handle, the PDU to send, and an empty PDU
structure to accept the response which includes the populated values for each OID in the
variable list.
11. At this point you can extract and manipulate the returned data either by utilizing built
in functions such as print_value() or by simply directly accessing the structures. Other
convince functions for value output can be found in the net-snmp/library/mib.h header.
12. Finally, to properly clean up, the PDU(s) should be freed and the sessions closed
using the snmp_free_pdu() and snmp_close() functions.
Result:
Thus the C program to simulate the Simple Network Management Protocol is execute
and the output is verified successfully
EX NO 4c
Aim:
To write a program for File Transfer Application using UDP socket.
Algorithm:
Server:
Step 1: Start
Step 2: Create a socket with address family AF_INET, type SOCK_DGRAM and default
Protocol 0.
Step 3: Initialize the socket and set its attributes.
Step 4: Bind the server to socket using bind function.
Step 5: Find the length of Client address and store it in a parameter called len.
26
Step 6: Read the file from the client by recvfrom() function and the required parameters.
Step 7: Write the file by sendto() function by setting up the required parameters.
Step 8: Close the connection.
Client:
Step 1: start
Step 2: Create a socket with address family AF_INET type SOCK_DGRAM and default
protocol 0.
Step 3: Initialize the socket and set its attribute set required port no.
Step 4:Type the UDP message from client
Step 5: Write the UDP message framed from client through sendto() function.
Step 6: The recvfrom() function then read the message sent by the client by setting the parameters
required.
Step 7: Close the connection.
Result:
Thus the C program for File Transfer Application using UDP socket is executed and the
output is verified successfully
EX NO 5a
SIMULATION OF ARP
Aim:
To write a program for the simulation of Address Resolution Protocol(ARP).
Algorithm: ARP
1. Include necessary header files.
2. Initialize the arpreq structure initially to zero.
3. Get the IPAddress of the system as command line argument.
4. Check whether the given IPAddress is valid.
5. Copy the IPAddress from sockaddr_in structure to arpreq structure using memcopy()system
call.
27
EX NO 5b
SIMULATION OF RARP
Aim:
To write a program to implement the Reverse Address Resolution Protocol(RARP).
Algorithm:
1. Start the program. Declare the variables using arrays
2. Calculate the Ethernet address and IP address using et[i]=i*3; ip[i]=rand()%50
3. Calculate the address resolution protocol value using arp=rand()%6 function
4. Display the Ethernet address of the system
5. If the system is connected to the server, then display the sender IP address, otherwise
display No response
6.Compile and execute the program. Stop the program
Result:
Thus the C program for the simulation of Reverse Address Resolution Protocol(RARP) is
executed and the output is verified successfully
EX NO 6
AIM:
To perform addition and subtraction of two numbers using remote procedure call.
THEORY:
28
RPCGEN is the RPC Protocol Compiler. This compiler creates the network interface
portion of a distributed application, effectively hiding from the programmer the details of writing
and debugging low-level network interface code.
rpcgen tool generates four C files for the specification file (simp.x). The output file
contains C source code for both output and data declarations.
File Name
Description
simp_clnt.c
Client side communication stub procedure
simp _svc.c
Server side communication stub procedure
Declaration of constants and types used in the code
simp.h
generated for both client and server.
XDR-eXternal Data Representation. Contains XDR
simp_xdr.c
procedure calls used in the client and server to marshal
29
arguments.
STEPS
1.
2.
3.
4.
5.
6.
SIMP.X
1. This defines the protocol definition for the application.
2. Define two remote procedures - Each must be called with a single parameter, a structure
that holds 2 integers.
3. The return value of each procedure is an int.
simpclient.c
1.
2.
3.
4.
Define the wrapper function that takes care of calling the RPC procedure.
Gather everything into a single data structure to send to the server.
Call the client stub created by rpcgen.
Create a CLIENT data structure that reference the RPC procedure SIMP_PROG, version
SIMP_VERSION running on the host specified by the first command line arg.
5. Get the 2 numbers that should be added, from the user.
6. Pass the numbers to the server for calculation and prints the output in the terminal.
Simpservice.c
1. This file contains the definition of the remote add and subtract procedure used by simple
RPC example
2. The return value of the procedure must be a pointer to integer.
3. Declare the variable result as static so we can return a pointer to it.
4. Define implementation of the method add_1_svc as add two arguments.
5. Define implementation of the method sub_1_svc as subtract second argument from first
argument.
OUTPUT
GENERATION OF STUBS AND HEADER FILE
$rpcgen -C -a simp.x
//Make sure that the following files are generated by rpcgen tool
30
$ ls
a.out
simpclient.c simp_server.c simp.x
Makefile.simp simp_clnt.c simpservice.c simp_xdr.c
simp_client.c simp.h
simp_svc.c
SERVER
$ cc simpservice.c simp_svc.c simp_xdr.c
$ ./a.out
Got request: adding 6, 3
Got request: subtracting 6, 3
CLIENT
$ cc simpclient.c simp_clnt.c simp_xdr.c
$ ./a.out 127.0.0.1 6 3
6+3=9
6-3=3
$
Result:
Thus the addition and subtraction of two numbers using remote procedure call is executed
and the output is verified successfully.
EX NO 7a
Aim
To write a program in C to simulate the Sliding Window Protocol.
31
Algorithm
Server
1. A TCP socket is created.
2. An Internet socket address structure is filled in with the wildcard address
(INADDR_ANY) and the servers well-known port (PORT).
3. The socket is converted into a listening socket by calling the listen function.
4. The server blocks in the call to accept, waiting for the client connection to complete.
5. When the connection is established, the server reads the source file name (which is to
be transferred) from the client using readn.
6. Then the contents of the source file are transferred byte by byte (assuming the window
size is 1) to the client.
7. Finally, the server closes the connected socket.
Client:
1. A TCP socket is created.
2. An Internet socket address structure is filled in with the servers IP address and the
same port number.
3. The connect function establishes the connection with the server.
4. The client reads a source file name and the destination file name from the user, sends
the source file name to the server using writen.
5. It then receives the byte by byte content of the file from the server and displays it.
OUTPUT
//sample.txt
GOOD DAY
//SERVER
$ cc slidingser.c
$ ./a.out
SERVER SOCKET BINDED
SERVER SOCKET listened
SERVER Socket accepted connection with a Client
File requested: sample.txt
Sending:GReceived ACK...
Sending:OReceived ACK...
Sending:OReceived ACK...
Sending:DReceived ACK...
Sending: Received ACK...
Sending:DReceived ACK...
Sending:AReceived ACK...
Sending:YReceived ACK...
Sending:
Received ACK...
$
//CLIENT
$ cc slidingcli.c
$ ./a.out 127.0.0.1
32
EX NO 7b
Aim
To write a program in C to simulate the Stop & Wait Protocol.
33
Algorithm
Sender:
1. Start the Program
2. Get the Packet from Network Layer
3. Create the frame structure
4. Send the frame created
5. If it is not a good frame call the physical layer to initiate the event else get the packet from
Network Layer and continue the Process.
6. Stop the Program
Receiver:
1. Physical Layer receives the frame and check for the structure.
2. If not a good frame call the physical layer else pass the frame to Network Layer.
3. Send Empty frame as an acknowledgement to sender and repeat the process.
Result:
Thus the C program to simulate the Stop & Wait Protocol is executed and the output is
verified successfully.
EX NO 8
AIM
To write a c program in UNIX to download a file from a HTTP server.
ALGORITHM
Server
1. Include necessary header files to support functions for Socket definitions,Socket Types, Internet
addresses, I/Ofunctions, Unix system calls.
2. Declare variables for Socket ID,Portnumber,Socket addresses, buffer,etc.
3. Create Socket for server.
4. Bind socket with addresses.
5. Specify number of allowed connections.
6. Wait for connection.
7. Accept connection (If any).
8. Repeat the steps 8and 9 until the socket is closed.
9. Read the requested file to be transmitted from the client
10. The requested file is transferred by write to the new location.
Client
1. Include necessary header files to support functions for Socket definitions, Socket types, Internet
addresses, I/O functions, Unix system calls.
2. Declare variables for Socket ID, Portnumber, Socket addresses, Character buffer, etc.
3. Create Socket for Client.
4. Connect client socket to the server socket addresses.
5. Repeat the steps 8and 9 until the socket is closed.
6. Send file name to the Connected Socket
7. Retrieve information from Connected Socket and display it..
Result:
Thus the c program in UNIX to download a file from a HTTP server is executed and the output
is verified successfully.
EX NO 9
Aim
35
Algorithm:
1.Start the program. Declare the variables using arrays.
2. Read the network address ,the Number of subnets and the subnet mask from the user.
3. Convert the given dotted decimal IP address and subnet mask into the binary form.
4. A subnet mask (or number) is used to determine the number of bits used for the subnet and host
portions of the address.
5. To create subnets, we increase the mask into required octet by enough bits to get subnets.
6. Now print all the subnet addresses.
For eg)
Lets subnet 129.99.0.0 into seven subnets.
129.99.0.0 is a Class B address with a natural mask of 255.255.0.0. To create subnets, we
increase the mask into the third octet by enough bits to get seven subnets. we see that three bits
will give us seven subnets, using an extended mask (subnet mask) of 255.255.224.0, as shown
below.
Result:
Thus the implementation of Subnetting is done and the output is verified successfully
EX NO 11a
AIM:
37
NS-2 ARCHITECTURE
Downloading/Installing ns&nam
One can build ns either from the various packages (Tcl/Tk, otcl, etc.), or can download an 'all-inone' package. web page: http://www.isi.edu/nsnam/ns/ns-build.html
Starting ns
Start ns with the command 'ns <tclscript>', where '<tclscript>' is the name of a Tcl script file
which defines the simulation scenario (i.e. the topology and the events). Just start ns without any
arguments and enter the Tcl commands in the Tcl shell, but that is definitely less comfortable.
Everything else depends on the Tcl script. The script might create some output on stdout, it might
write a trace file or it might start nam to visualize the simulation.
Starting nam
One can either start nam with the command 'nam <nam-file>' where '<nam-file>' is the name of a
nam trace file that was generated by ns, or one can execute it directly out of the Tcl simulation
script for the simulation which you want to visualize.
38
exit 0
}
You don't really have to understand all of the above code yet. It will get clearer to you once you
see what the code does.
The next line tells the simulator object to execute the 'finish' procedure after 5.0 seconds of
simulation time.
$ns at 5.0 "finish"
You probably understand what this line does just by looking at it. ns provides you with a very
simple way to schedule events with the 'at' command.
The last line finally starts the simulation.
$ns run
Ns-2 MAIN CONSOLE WITH NETWORK ANIMATOR
Result:
Thus the Network Simulator NS2 is studied successfully.
40
EX No 12
AIM:
To implement different routing algorithms and compare their performance using network
simulator (ns2)
a ) LINK STATE ROUTING ALGORITHM
ALGORITHM:
1. Define new simualtor
2. Define different colors for data flows (for NAM)
3. Define a new Trace file and open it
4. Define a new NAM Trace file and open it
5. Define a 'finish' procedure to flush trace record in the `trace and trace output files.
6. Define the routing protocol as Link State (LS)
7. Create six nodes n0,n1,..n5
8. Create links between the nodes with 0.3Mb and 10 ms Link with DropTail option
9. Give node position (for NAM) to place six nodes in the layout
10. Setup a TCP connection attach TCP Source Agent to node n0 and TCP sink agent to
node n5
11. Setup a FTP over TCP connection
12. Define configuration such that link between nodes n1 and n4 to be failed at 1.0 interval,
and up again at 4.5 interval
13. Start the simulation
OUTPUT
//routing1.tr
+ 0.00017 0 1 rtProtoDV 6 ------- 0 0.2 1.1 -1 0
- 0.00017 0 1 rtProtoDV 6 ------- 0 0.2 1.1 -1 0
+ 0.007102 2 1 rtProtoDV 6 ------- 0 2.1 1.1 -1 1
- 0.007102 2 1 rtProtoDV 6 ------- 0 2.1 1.1 -1 1
+ 0.007102 2 3 rtProtoDV 6 ------- 0 2.1 3.1 -1 2
- 0.007102 2 3 rtProtoDV 6 ------- 0 2.1 3.1 -1 2
r 0.01033 0 1 rtProtoDV 6 ------- 0 0.2 1.1 -1 0
r 0.017262 2 1 rtProtoDV 6 ------- 0 2.1 1.1 -1 1
+ 0.017262 1 0 rtProtoDV 6 ------- 0 1.1 0.2 -1 3
- 0.017262 1 0 rtProtoDV 6 ------- 0 1.1 0.2 -1 3
b) FLOODING
PROCEDURE
Flooding is a simple routing algorithm in which every incoming packet is sent through
every outgoing link except the one it arrived on.
Flooding is used in bridging and in systems such as Usenet and peer-to-peer file
sharing and as part of some routing protocols, includingOSPF, DVMRP, and those used in ad-hoc
wireless networks.
There are generally two types of flooding available, Uncontrolled Flooding and Controlled
Flooding.
Uncontrolled Flooding is the fatal law of flooding. All nodes have neighbours and route
packets indefinitely. More than two neighbours creates a broadcast storm.
Controlled Flooding has its own two algorithms to make it reliable, SNCF (Sequence
Number Controlled Flooding) and RPF (Reverse Path Flooding). In SNCF, the node attaches its
own address and sequence number to the packet, since every node has a memory of addresses and
sequence numbers. If it receives a packet in memory, it drops it immediately while in RPF, the
node will only send the packet forward. If it is received from the next node, it sends it back to the
sender.
There are several variants of flooding algorithm. Most work roughly as follows:
1. Each node acts as both a transmitter and a receiver.
2. Each node tries to forward every message to every one of its neighbours except the source
node.
This results in every message eventually being delivered to all reachable parts of the
network.Algorithms may need to be more complex than this, since, in some case, precautions have
to be taken to avoid wasted duplicate deliveries and infinite loops, and to allow messages to
eventually expire from the system. A variant of flooding called selective flooding partially
addresses these issues by only sending packets to routers in the same direction. In selective
43
flooding the routers don't send every incoming packet on every line but only on those lines which
are going approximately in the right direction.
c) DISTANCE VECTOR ROUTING ALGORITHM
ALGORITHM:
1. Define new simulator
2. Define different colors for data flows (for NAM)
3. Define a new Trace file and open it
4. Define a new NAM Trace file and open it
5. Define a 'finish' procedure to flush trace record in the `trace and trace output files.
6. Define the routing protocol as Distance Vector (DV)
7. Create six nodes n0,n1,..n5
8. Create links between the nodes with 0.3Mb and 10 ms Link with DropTail option
9. Give node position (for NAM) to place six nodes in the layout
10. Setup a TCP connection attach TCP Source Agent to node n0 and TCP sink agent to
node n5
11. Setup a FTP over TCP connection
12. Define configuration such that link between nodes n1 and n4 to be failed at 1.0 interval,
and up again at 4.5 interval
13. Start the simulation
PROGRAM:
3. Count the number of packets sent by checking the status of the packet (source and
destination) and flag as receive (r)
4. Count the number of packets dropped by checking the status of the packet (source and
destination) and flag as drop (d)
COMPARISION
1. Save the above file as measure-loss.awk
2. Open terminal
3. After running routing1.tcl and routing2.tcl
4. Run the awk script to count number of packets sent between nodes 0 and 1
Type the command
$gwak -f measure-loss.awk <filename.tr>
steps
1. save the above file as measure-loss.awk
2. Open terminal
3. after running routing1.tcl and routing2.tcl
4. Run the awk script to count number of packets sent between nodes 0 and 1
Type the command
$gwak -f measure-loss.awk routing1.tr
number of packets sent:616 lost:2
$
$gawk -f measure-loss.awk routing1.tr
number of packets sent:203 lost:0
*/
/*
Open routing1.tr
search the file
.
.
d 1 1 4 tcp 1040 ------ 1 0.0 5.0 17 62
..
.
You will have a trace log showing the dropped packet information
*/
Result :
Thus the implementation of different routing algorithms and compare their performance
using network simulator (ns2) is executed and the output is verified successfully.
45
BIT STUFFING
AIM
To write a program that takes a binary file as input and performs the bit stuffing.
ALGORITHM
Server
1. Include necessary header files to support functions for Socket definitions, Socket Types, Internet
addresses, I/Ofunctions, Unix system calls.
2. Declare variables for Socket ID,Portnumber,Socket addresses, buffer,etc.
3. Create Socket for server.
4. Bind socket with addresses.
5. Specify number of allowed connections.
6. Wait for connection.
7. Accept connection (If any).
8. Take the binary input file.
9. Perform a bit stuffing by replacing every sixth bit by 0, if it is 1 , else check the next sixth bit and repeat
the process
10. Repeat the steps 8and 9 until the socket is closed.
11. Retrieve information from Connected Socket and display it.
12. Send information to Connected Socket.
13. Close Connected socket.
Client
1. Include necessary header files to support functions for Socket definitions, Socket types, Internet
addresses, I/O functions, Unix system calls.
2. Declare variables for Socket ID, Portnumber, Socket addresses, Character buffer, etc.
3. Create Socket for Client.
4. Connect client socket to the server socket addresses.
5. Enter the source file name for which the bit stuffing is performed.
6. Repeat the steps 8and 9 until the socket is closed.
7. Send information to Connected Socket
8. Retrieve information from Connected Socket and display it..
9. Close Connected socket.
SAMPLE OUTPUT :
CLIENT MESSAGE
FILENAME :source.txt
Input 1111111111111
111110111110
SAMPLE OUTPUT
Source filename: source.txt
RESULT:
Thus a c program for bit stuffing is executed and the output is verified successfully.
46
EX No 14
Aim
To simulate the implementation of the routing protocol BGP (Border Gateway Protocol)
Objective
Many nodes are obtained to check which node has the shortest path to source node . The
measures compared are cost of the node matrix and the minimum distance.
How it is being achieved?
Read n number of nodes and the cost for the node matrix is found. Make one
node as source node.Compute the minimum distance of each node with the source node. Then
the node with shortest path to source node is printed as result.
Syntax & keywords
To get number of nodes
printf("\n Enter the number of nodes:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("\n Enter the distance between the host %d - %d:",i+1,j+1);
scanf("%d",&a[i][j]);
}
}
EXECUTION OF THE SOURCE CODE
Quantity
System
O/S
Windws 98
Compiler
47
This program implements BGP to get host cost matrix and path as input and identifies
the shortest path from source as output .
ALGORITHM
1. Read the no. of nodes n.
2. Read the cost matrix for the path from each node to another node.
3. Initialize SOURCE to 1 and include 1.
4. Compute D of a node which is the distance from source to that corresponding node.
5. Repeat step 6 to step 8 for n-l nodes.
6. Choose the node that has not been included whose distance is minimum and include
the node.
7. For every other node not included compare the distance directly from the source with the
distance to reach the node using the newly included node.
8. Take the minimum value as the new distance.
9. Print all the nodes with shortest path cost from source node.
OUTPUT
Enter the number of nodes: 5
Enter the distance between the host: 10
The output matrix :
10 15 20 25 30
RESULT:
Thus the above program to simulate the Routing Protocols using border gateway
protocol is executed and the output is verified successfully.
48
49