NW Lab-1

fork() System Call
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
pid_t pid;
pid = fork();
if (pid == 0)
printf("I am Child Process\n");
else
printf("I am Parent Process\n");
}
OUTPUT
exec() System Call

exec1.c
#include <stdio.h>
#include <unistd.h>
int main() {
char *args[] = {"./exec2", NULL};
printf("We are using exec() system call\n");
execv(args[0], args);
printf("Back to exec1.c");
}
exec2.c
#include <stdio.h>
#include <unistd.h>
int main()
{
printf("We are in exec2.c\n");
}
OUTPUT
exit() System Call

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
int main() {
pid_t pid;
pid = fork();
int status;
if (pid == 0) {
printf("Child\n");
sleep(10);
exit(10);}
else {
printf("Parent\n");
wait(&status);
printf("Exit Status is %d\n", WEXITSTATUS(status));
}
}
OUTPUT
wait() System Call

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>
int main() {
pid_t pid;
pid = fork();
int status;
if (pid == 0) {
printf("Child\n");
sleep(10);
} else {
printf("Parent\n");
wait(&status);
printf("I am in Parent Process\n");
}
}
OUTPUT
open() and close() System Calls

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
int fd1 = open("input.txt", O_RDONLY);
if (fd1 < 0)
{
perror("c1");
exit(1);
}
printf("Opened the fd = %d\n", fd1);
if (close(fd1) < 0)
{
perror("c1");
exit(1);
}
printf("Closed the fd\n");
}
OUTPUT
read() and write() System Call

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
char buff[20];
int fd1 = open("input.txt", O_RDWR);
int fd2 = open("sample.txt", O_RDWR);
if (fd1 < 0) {
perror("c1");
exit(1);
}
printf("Reading file....\n\n");
read(fd1, buff, 20);
printf("Content of file is: %s\n", buff);
printf("\nWriting to file......\n");
write(fd2, buff, sizeof(buff));
printf("Written successfully.\n");
if (close(fd1) < 0) {
perror("c1");
exit(1);
}
}
input.txt
Computer Networks
sample.txt
Computer Networks
OUTPUT
OUTPUT
Client- Server Communication using Socket Programming and TCP as Transport
Layer
Server Program (tcpserver.c)
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<fcntl.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
int main( int argc, char *argv[])
{
struct sockaddr_in server, cli;
int cli_len;
int sd, n, i, len;
int data, temp;
char buffer[100];
if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("Socket failed:");
exit(1);
}
// server socket address structure initialisation
bzero(&server, sizeof(server) );
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[1]));
server.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sd, (struct sockaddr*)&server, sizeof(server)) < 0)
{
perror("bind failed:");
exit(1);
}
listen(sd,5);
if((data = accept(sd , (struct sockaddr *) &cli, &cli_len)) < 0)
{
perror("accept failed:");
exit(1);
}
read(data,buffer, sizeof(buffer));
len = strlen(buffer);
for( i =0; i<= len/2; i++)
{
temp = buffer[i];
buffer[i] = buffer[len - 1-i];
buffer[len-1-i] = temp;
}
write (data,buffer, sizeof(buffer));
close(data);
close(sd);
}
Client Program (tcpclient.c)

#include<stdio.h>
#include<fcntl.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
int main( int argc, char *argv[])
{
struct sockaddr_in server;
int sd ;
char buffer[200];
if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

{
perror("Socket failed:");
exit(1);
}
// server socket address structure initialisation
bzero(&server, sizeof(server) );
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[2]));
inet_pton(AF_INET, argv[1], &server.sin_addr);
if(connect(sd, (struct sockaddr *)&server, sizeof(server))< 0)
{
perror("Connection failed:");
exit(1);
}
printf("enter the string: ");
fgets(buffer, sizeof(buffer), stdin);
buffer[strlen(buffer) - 1] = '\0';
write (sd,buffer, sizeof(buffer));
read(sd,buffer, sizeof(buffer));
printf("%s\n", buffer);
close(sd);
}
OUTPUT
Server
Client
Client- Server Communication using Socket Programming and UDP as Transport
Layer
Server Program (udpserver.c)
#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<stdlib.h>
#include<unistd.h>
int main(int argc, char * argv[])
{
int n;
int sock_fd;
int i,j,k;
int row_1, row_2, col_1, col_2;
struct sockaddr_in servaddr,
cliaddr;
int len = sizeof(cliaddr);
int matrix_1[10][10], matrix_2[10][10], matrix_product[10][10];
int size[2][2];
if(argc != 2)
{
fprintf(stderr, "Usage: ./server port\n");
exit(1);
}
if((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
printf("Cannot create socket\n");
exit(1);
}
bzero((char*)&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(atoi(argv[1]));
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sock_fd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
{
perror("bind failed:");
exit(1);
}
// MATRICES RECEIVE
if((n = recvfrom(sock_fd, size, sizeof(size), 0, (struct sockaddr *)&cliaddr, &len)) ==

-1)
{
perror("size not received:");
exit(1);
}
// RECEIVE MATRIX 1
if((n = recvfrom(sock_fd, matrix_1, sizeof(matrix_1), 0, (struct sockaddr *)&cliaddr,
&len)) == -1)
{
perror("matrix 1 not received:");
exit(1);
}
// RECEIVE MATRIX 2
if((n = recvfrom(sock_fd, matrix_2, sizeof(matrix_2), 0, (struct sockaddr *)&cliaddr,
&len)) == -1)
{
perror("matrix 2 not received:");
exit(1);
}
row_1 = size[0][0];
col_1 = size[0][1];
row_2 = size[1][0];
col_2 = size[1][1];
for (i =0; i < row_1 ; i++)
for (j =0; j <col_2; j++)
{
matrix_product[i][j] = 0;
}
for(i =0; i< row_1 ; i++)
for(j=0; j< col_2 ; j++)
for (k=0; k < col_1; k++)
{
matrix_product[i][j] += matrix_1[i][k]*matrix_2[k][j];
}
n = sendto(sock_fd, matrix_product, sizeof(matrix_product),0, (struct
sockaddr*)&cliaddr,
sizeof(cliaddr));
if( n < 0)
{
perror("error in matrix product sending");
exit(1);
}
close(sock_fd);
}
Client Program (udpclient.c)

#include<stdio.h>
#include<string.h>
#include<fcntl.h>
#include<stdlib.h>
#include<unistd.h>
int main(int argc, char * argv[])
{
int i,j,n,p,q;
int sock_fd;
struct sockaddr_in servaddr;
int matrix_1[10][10], matrix_2[10][10], matrix_product[10][10];
int size[2][2];
int num_rows_1, num_cols_1, num_rows_2, num_cols_2,n2;
if(argc != 3)
{
fprintf(stderr, "Usage: ./client IPaddress_of_server port\n");
exit(1);
}
printf("Enter the number of rows of first matrix\n");
scanf("%d", &num_rows_1);
printf("Enter the number of columns of first matrix\n");
scanf("%d", &num_cols_1);
printf("Enter the values row by row one on each line\n" );
for ( i = 0; i < num_rows_1; i++){
for( j=0; j<num_cols_1; j++)
{
scanf("%d", &matrix_1[i][j]);
}}
size[0][0] = num_rows_1;
size[0][1] = num_cols_1;
printf("Enter the number of rows of second matrix\n");
scanf("%d", &num_rows_2);
printf("Enter the number of columns of second matrix\n");
scanf("%d", &num_cols_2);
if( num_cols_1 != num_rows_2)
{
printf("MATRICES CANNOT BE MULTIPLIED\n");
exit(1);
}
printf("Enter the values row by row one on each line\n");
for (p = 0; p < num_rows_2; p++){
for(q=0; q<num_cols_2; q++)
{
scanf("%d", &matrix_2[p][q]);
}}
size[1][0] = num_rows_2;
size[1][1] = num_cols_2;
if((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
printf("Cannot create socket\n");
exit(1);
}
bzero((char*)&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(atoi(argv[2]));
inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
// SENDING MATRIX WITH SIZES OF MATRICES 1 AND 2

n = sendto(sock_fd, size, sizeof(size),0, (struct sockaddr*)&servaddr,
sizeof(servaddr));
if( n < 0)
{
perror("error in matrix 1 sending");
exit(1);
}
// SENDING MATRIX 1
n = sendto(sock_fd, matrix_1, sizeof(matrix_1),0, (struct sockaddr*)&servaddr,
sizeof(servaddr));
if( n < 0)
{
exit(1);
}
// SENDING MATRIX 2
n = sendto(sock_fd, matrix_2, sizeof(matrix_2),0, (struct sockaddr*)&servaddr,
sizeof(servaddr));
if( n < 0)
{
exit(1);}
printf("Waiting for response\n");
if((n=recvfrom(sock_fd, matrix_product, sizeof(matrix_product),0, NULL, NULL))
== -1)
{
perror("read error from server:");
exit(1);
}
printf("\n\nTHE PRODUCT OF MATRICES IS \n\n\n");
for( i=0; i < num_rows_1; i++)
{
for( j=0; j<num_cols_2; j++)
{
printf("%d ",matrix_product[i][j]);
}
printf("\n");
}
close(sock_fd);
}
OUTPUT
Server
Client
OUTPUT
Sliding Window Flow Control Protocol
Stop and Wait
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char* argv[])
{
srand(time(NULL));
int sspace = 3;
int sender_seq_bit=0, receiver_seq_bit=0;

int transmit_packet=0, transmit_seq=-1;
int sender_left=10, sender_packet=0;
while(sender_left > 0)
{
//send packet
transmit_seq = sender_seq_bit;
transmit_packet = sender_packet;
printf("\nSender sent packet %d with sequence %d.\n",sender_packet,
sender_seq_bit);
if(rand()%sspace != 0)
{
//receive packet
printf("Receiver received %d with sequence %d.\n",transmit_packet,
transmit_seq );
if(transmit_seq != receiver_seq_bit)
{
transmit_packet = 0;
transmit_seq = receiver_seq_bit;
printf("Receiver discards packet.\n");
}
else
{
receiver_seq_bit = 1-receiver_seq_bit;
transmit_seq = receiver_seq_bit;
printf("Receiver sends ack with bit %d\n", transmit_seq);
}
}
else
{
//packet lost
printf("Packet %d lost.\n", transmit_packet);
transmit_packet = -1;
transmit_seq = -1;
}
if(transmit_packet>=0)
{
{
//sender receives ack
printf("Sender received ACK with sequence %d.\n",
transmit_seq );
if(transmit_seq != sender_seq_bit)
{
// correct ack
sender_left-=1;
sender_packet += 1;
sender_seq_bit = 1 - sender_seq_bit;
}
}
else
{
//packet lost
printf("ACK lost.\n");
}
}
transmit_seq = -1;
}
return 0;
}
OUTPUT
Go back N
#include<stdio.h>
#include<time.h>
#define fail_limit 3
int fr,win_siz,err_no;
int err[100];
int sh=1,st=1,rh=0,rt=1;
int fail_con=0,fail[100],f=0,ack_f=fail_limit;
void read_val();
void assign(int arr[]);
void send();
void recive();
void main(){
read_val();
// int sent[fr],rec[fr];
// assign(sent);
assign(fail);
printf("Sender,reciever and ack_fail\n");
while(sh<=fr){
send();
recive();
printf("\n");
}
}
void read_val(){
printf("Number of frames: ");
scanf("%d",&fr);
fr++;
printf("Window size: ");
scanf("%d",&win_siz);
printf("Number of errors: ");
scanf("%d",&err_no);
printf("Error numbers: ");
for(int i=0;i<err_no;i++)
scanf("%d",&err[i]);
}
void assign(int arr[]){
for(int i=0;i<fr;i++)
arr[i]=0;
}
void send(){
if(fail_con==1){
ack_f--;
}
if(ack_f<fail_limit && sh>=fr){
ack_f=0;
}
if(ack_f<=0){
printf("\nRetransmmiting %d\n\n",sh-fail_limit-1);
ack_f=fail_limit;
fail_con=0;
sh-=fail_limit;
st-=fail_limit;
}
for(int i=sh;i<fr && i<sh+win_siz;i++){
printf("%d ",i);
fflush(stdout);
}
printf("\t");
sh++;
}
void recive(){
if(fail_con==1){
for(int k=rh-1;k<rh+win_siz-1;k++){
printf("%d ",k);
}
printf("\t");
fail[f]=fail[f-1]+1;
f++;
for(int u=0;u<f;u++){
printf("%d ",fail[u]);
fflush(stdout);
}
return;
}
for(int i=rh;fr && i<=rt;i++){
for(int j=0;j<err_no;j++){
if(i==err[j]){
for(int k=rh-1;k<rh+win_siz-1;k++){
printf("%d ",k);
}
printf("\t");
fail_con=1;
fail[f++]=i;
printf("%d",i);
fflush(stdout);
err[j]=-1;
return;
}
}
}
if(rh==0){
rh++;
printf("\t");
return;
}
for(int i=rh;i<fr && i<=rt;i++){
printf("%d ",i);
fflush(stdout);
}
printf("\t");
if(1+rt-rh<win_siz){
rt++;
}
else{
rt++;
rh++;
}
}
OUTPUT
OUTPUT
Selective Repeat
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char* argv[])
{
srand(time(NULL));
int sspace = 6;
int seq_size = 4;
int sender_packets[] = {0, 1, 2, 3, 4, 5};
int total_size=6;
int sender_seq=0, receiver_seq=0;
int transmit_packet=0, transmit_seq=-1;
int sender_packet=0, sender_win_start=0;
int sender_start_seq=0;
int sender_pos=0;
while(sender_win_start < total_size)
{
//send packet
if((sender_pos-sender_win_start >= seq_size-1) ||
(sender_pos+sender_win_start >= total_size))
{
sender_pos=0;
sender_seq = sender_start_seq;
}
transmit_seq = sender_seq;
transmit_packet = sender_packets[sender_win_start+sender_pos];
printf("\n");
for(int i=0; i<seq_size-1; i++)
{
if(i+sender_win_start < total_size)
printf("%d ", sender_packets[i+sender_win_start]);
}
printf("\nSender sent packet %d with sequence %d.\n",transmit_packet,
transmit_seq);
sender_seq = (sender_seq+1)%seq_size;
sender_pos++;
{
//receive packet
printf("Receiver received %d with sequence %d.\n",transmit_packet,
transmit_seq );
if(transmit_seq != receiver_seq)
{
transmit_seq = receiver_seq;
printf("Receiver discards packet.\n");
}
else
{
receiver_seq = (receiver_seq+1)%seq_size;
transmit_seq = receiver_seq;
printf("Receiver sends ack with sequence %d\n", transmit_seq);
}
}
else
{
//packet lost
printf("Packet %d lost.\n", transmit_packet);
transmit_seq = -1;
}
if(transmit_packet>=0)
{
{
//sender receives ack
printf("Sender received ACK with sequence %d.\n",
transmit_seq );
if(transmit_seq >= sender_start_seq)

sender_win_start += transmit_seq-sender_start_seq;
else
sender_win_start += seq_size+transmit_seq-
sender_start_seq;
sender_start_seq = transmit_seq;
sender_seq = transmit_seq;
sender_pos = 0;
}
else
{
//packet lost
printf("ACK lost.\n");
}
}
transmit_seq = -1;
}
return 0;
}
************ OUTPUT IS WITH GO BACK N OUTPUT **********

Distance Vector Routing
#include<stdio.h>
struct node
{
unsigned dist[20];
unsigned from[20];
}rt[10];
int main()
{
int dmat[20][20];
int n,i,j,k,count=0;
printf("\nEnter the number of nodes : ");
scanf("%d",&n);
printf("\nEnter the cost matrix :\n");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
scanf("%d",&dmat[i][j]);
dmat[i][i]=0;
rt[i].dist[j]=dmat[i][j];
rt[i].from[j]=j;
}
do
{
count=0;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
for(k=0;k<n;k++)
if(rt[i].dist[j]>dmat[i][k]+rt[k].dist[j])
{
rt[i].dist[j]=rt[i].dist[k]+rt[k].dist[j];
rt[i].from[j]=k;
count++;
}
}while(count!=0);
for(i=0;i<n;i++)
{
printf("\n\nState value for router %d is \n",i+1);
for(j=0;j<n;j++)
{
printf("\t\nnode %d via %d Distance%d",j+1,rt[i].from[j]+1,rt[i].dist[j]);
}
}
printf("\n\n");
}
************ OUTPUT IS WITH UDP CLIENT OUTPUT **********

Link State Routing
#include<stdio.h>
//#include<conio.h>
#define INFINITY 9999
#define MAX 10
void dijkstra(int G[MAX][MAX],int n,int startnode);
int main()
{
int G[MAX][MAX],i,j,n,u;
printf("Enter no. of vertices:");
scanf("%d",&n);
printf("\nEnter the adjacency matrix:\n");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&G[i][j]);
printf("\nEnter the starting node:");
scanf("%d",&u);
dijkstra(G,n,u);
return 0;
}
void dijkstra(int G[MAX][MAX],int n,int startnode)
{
int cost[MAX][MAX],distance[MAX],pred[MAX];
int visited[MAX],count,mindistance,nextnode,i,j;
//pred[] stores the predecessor of each node
//count gives the number of nodes seen so far
//create the cost matrix
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(G[i][j]==0)
cost[i][j]=INFINITY;
else
cost[i][j]=G[i][j];
//initialize pred[],distance[] and visited[]
for(i=0;i<n;i++)
{
distance[i]=cost[startnode][i];
pred[i]=startnode;
visited[i]=0;
}
distance[startnode]=0;
visited[startnode]=1;
count=1;
while(count<n-1)
{
mindistance=INFINITY;
//nextnode gives the node at minimum distance
for(i=0;i<n;i++)
if(distance[i]<mindistance&&!visited[i])
{
mindistance=distance[i];
nextnode=i;
}
//check if a better path exists through nextnode
visited[nextnode]=1;
for(i=0;i<n;i++)
if(!visited[i])
if(mindistance+cost[nextnode][i]<distance[i])
{
distance[i]=mindistance+cost[nextnode][i];
pred[i]=nextnode;
}
count++; }
//print the path and distance of each node
for(i=0;i<n;i++){
if(i!=startnode)
{
printf("\nDistance of node%d=%d",i,distance[i]);
printf("\nPath=%d",i);
j=i;
do
{ j=pred[j];
printf("<-%d",j);
}while(j!=startnode);
}
printf("\n");
}
}
******* OUTPUT IS WITH READ-WRITE SYSTEM CALL OUTPUT ********

Simple Mail Transfer Protocol
Server Program (smtpserver.c)
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <stdbool.h>
#define domain "server.smtp.com"
int receive_image(int socket)
{
int recvsize;
int size;
int readsize;
int writesize;
int packetindex;
int status;
char img_array[10240];
FILE *fpimage;
do{
status = read(socket, &size, sizeof(int));
}while(status<0);
printf("RECEIVED :\nPacket is received!");
//printf("Packet Size : %i\n",status);
//printf("Image Size : %i\n",size);
printf(" \n");
char buffer[] = "Success!";
do{
status = write(socket, &buffer, sizeof(int));
}while(status<0);
printf("Reply is sent successfully!\n");
printf(" \n");
fpimage = fopen("received.jpeg", "w");
if(fpimage == NULL)
{
printf("Error occured while opening the Image file!\n");
return -1;
}
struct timeval timeout = {10,0};
fd_set fd_s;
int bufferfd;
while(recvsize < size) {
FD_ZERO(&fd_s);
FD_SET(socket,&fd_s);
bufferfd = select(FD_SETSIZE,&fd_s,NULL,NULL,&timeout);
if (bufferfd < 0)
printf("Error occured due to bad file descriptor set.\n");
if (bufferfd == 0)
printf("Error occured due to buffer read timeout expired.\n");
if(bufferfd > 0)
{
do{
readsize = read(socket, img_array, 10240);
}while(readsize < 0);
//printf("Packet Received number : %i\n",packetindex);
//printf("Packet size : %i\n",readsize);
writesize = fwrite(img_array,1,readsize, fpimage);
printf("Image size written : %i\n",writesize);
if(readsize!=writesize)
{
printf("Error occured while reading!\n");
}
recvsize += readsize;
packetindex++;
printf("Total Received Image size : %i\n",recvsize);
printf(" \n");
}
}
}
int main(int argc, char *argv[])
{
int sockfd, newsockfd, n, portno, clilen;
struct sockaddr_in serv_addr, cli_addr;
char servers[2][100] = {"smtp.gmail.com","smtp.yahoo.com"};
char buff[10240]; //used for buffer the incoming data from client
char command[50]; //used to read command RECEIVED from client
sockfd = socket(AF_INET, SOCK_STREAM,0);
if(sockfd < 0)
{
perror("\nError occured while creating the socket!\n");
}
bzero((char *) &serv_addr, sizeof(serv_addr));
portno = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
{
perror("\nSocket binding failed!\n");
}
listen(sockfd,5);
clilen = sizeof(cli_addr);
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0)
{
perror("\nError occured while accepting on socket!\n");
}
//Implementing responses which SMTP Server sends to Client for Acknowledgement in
the process of Email Receiving
do
{
bzero(buff,10240);
n = read(newsockfd,buff,10239);
if (n < 0)
{
printf("\nError occured while reading from socket!\n");
break;
}
else
{
buff[n] = '\0';
if(strstr(buff,"HELO")!=NULL)
{
printf("RECEIVED : %s",buff);
bzero(buff,10240);
strcpy(buff,"250 Hello ");
strcat(buff, domain);
printf("SENT : %s\n\n",buff);
n = write(newsockfd,buff,strlen(buff));
if (n<0) { perror("Error occured while writing to socket!"); }
}
else if(strstr(buff,"MAIL FROM")!=NULL)
{
bzero(buff,10240);
strcpy(buff,"250 OK");
}
else if(strstr(buff,"RCPT TO")!=NULL)
{
bzero(buff,10240);
strcpy(buff,"250 OK");
}
else if(strstr(buff,"DATA")!=NULL)
{
bzero(buff,10240);
strcpy(buff,"354 Send message content; end with <CRLF>.<CRLF>");
if (n < 0) { perror("Error occured while writing to socket!"); }
bzero(buff,10240);
if (n < 0){ printf("\nError occured while reading from socket!\n"); break; }
printf("\n\n----------| Received Email Header & Content |----------\n\n%s\n",buff);
printf("-------------------------------------------------------\n\n");
bzero(buff,10240);
if (n < 0){ printf("\nError occured while reading from socket!\n"); break; }
if(strstr(buff,".")!=NULL){
bzero(buff,10240);
strcpy(buff,"250 OK, message accepted for delivery.");
}
}
else if(strstr(buff,"Attachment") != NULL)
{
bzero(buff,10240);
strcpy(buff,"420 Send attachment");
if(receive_image(newsockfd) != -1)
{
printf("Attached Image file received!\n");
bzero(buff,10240);
strcpy(buff,"250 Image received successfully");
}
}
else if(strstr(buff,"QUIT") != NULL)
{
break;
}
}
}while(strcmp(buff,"QUIT") != 0);
bzero(buff,10240);
strcpy(buff,"221 Bye");
printf("\nConnection closed successfully with the client!\n\n");
return 0;
}
Client Program (smtpclient.c)

#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#define domain "server.smtp.com"
char mail_from[100];
char mail_to[100];
void send_image(int socket)
{
FILE *fpimage;
int size;
int readsize;
int status;
int packet_index = 1;
char send_buffer[10239];
char read_buffer[256];
char f_name[100];
printf("\nEnter Image Path/Image file name : ");
scanf("%s",f_name);
fpimage = fopen(f_name, "r");
printf("\nCLIENT: \nGetting Image Size...\n");
if(fpimage == NULL){
printf("Error occured while opening Image File!\n");
}
fseek(fpimage, 0, SEEK_END);
size = ftell(fpimage);
fseek(fpimage, 0, SEEK_SET);
printf("Total Image size: %i\n",size);
printf("Sending Image Size\n");
write(socket, (void *)&size, sizeof(int));
printf("Sending Image as a byte array...");
do{
status=read(socket, &read_buffer , 255);
//printf("Bytes read: %i\n",status);
}while(status < 0);
//printf("Data successfully received in socket!\n");
//printf("Socket Data: %s\n", read_buffer);
while(!feof(fpimage))
{
readsize = fread(send_buffer, 1, sizeof(send_buffer)-1, fpimage);
do{
status = write(socket, send_buffer, readsize);
}while(status<0);
//printf("Packet number: %i\n",packet_index);
//printf("Packet size sent: %i\n",readsize);
printf(" \n");
printf(" \n");
packet_index++;
bzero(send_buffer, sizeof(send_buffer));
}
}
char * Mail_Header(char *from,char *to,char *sub,char *content)
{
time_t t;
time(&t);
char *header = NULL;
char date[26];
char DATE_h[8 + strlen(date)];
char sender[8 + strlen(from)]; //FROM: sender's_email\r\n
char recep[6 + strlen(to)]; //TO: recepient's_email\r\n
char subject[11 + strlen(sub)];
char content_a[1 + strlen(content) + 2 + 1 + 1];
strftime(date, (33), "%a %d %b %Y %H:%M:%S",localtime(&t));
sprintf(DATE_h,"DATE: %s\r\n",date);
sprintf(sender,"FROM: %s\r\n",from);
sprintf(subject,"Subject: %s\r\n",sub);
sprintf(recep,"TO: %s\r\n",to);
//extra \n is used to end the header part
sprintf(content_a,"%s\r\n",content);
int header_length = strlen(DATE_h) + strlen(sender) + strlen(subject) + strlen(recep) +
strlen(content_a);
header = (char *) malloc(header_length * sizeof(char));
memcpy(&header[0], &DATE_h, strlen(DATE_h));
memcpy(&header[0 + strlen(DATE_h)], &sender , strlen(sender));
memcpy(&header[0 + strlen(DATE_h) + strlen(sender)], &subject , strlen(subject));
memcpy(&header[0 + strlen(DATE_h) + strlen(sender) + strlen(subject)], &recep ,
strlen(recep));
memcpy(&header[0 + strlen(DATE_h) + strlen(sender) + strlen(subject) + strlen(recep)],
&content_a , strlen(content_a));
return header;
}
int main(int argc, char *argv[])
{
int socket_id,n;
int portno;
struct sockaddr_in serv_addr;
struct hostent *server;
char cname[256];
char buff[10240];
if(argc < 3)
{
perror("\nPlease enter the hostname and port number.\n");
exit(0);
}
portno = atoi(argv[2]);
socket_id = socket(AF_INET,SOCK_STREAM, 0);
if(socket_id < 0)
{
perror("\nError occured while opening the socket!\n");
exit(0);
}
server = gethostbyname(argv[1]);
if(server == NULL)
{
perror("\nError: No such host found!\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr,server->h_length);
serv_addr.sin_port = htons(portno);
//connect to the server
int connect_id;
connect_id = connect(socket_id,(struct sockaddr *)&serv_addr, sizeof(serv_addr));
if(connect_id < 0)
{
perror("Error occured while connecting to server...\n");
}
//Implementing commands which are used b/w Client and SMTP Server for
communication
do
{
printf("Enter the command : ");
intake: gets(cname);
//cname[strlen(cname) + 1] = '\0';
char code[4]; //to store the 3 digit response code received from server
if(strcasecmp(cname,"HELO") == 0)
{
bzero(buff,10240);
strcpy(buff,"HELO ");
strcat(buff, domain);
strcat(buff,"\r\n");
n = write(socket_id,buff,strlen(buff));
if(n < 0)
{
printf("\nError occured while writing to socket!\n");
}
printf("\nCLIENT : %s",buff); //HELO domain
bzero(buff,10240);
n = read(socket_id,buff,10239);
if(n < 0)
{
}
printf("SERVER : %s\n",buff); //250 Hello domain
//checking error
code[0] = buff[0];
code[1] = buff[1];
code[2] = buff[2];
code[3] = '\0';
if(strcmp(code,"250") == 0)
{
printf("\nGo to next command...\n\n");
}
else{
printf("\nError occured!\n\n");
}
fflush(stdin);
}
else if(strcasecmp(cname,"MAIL FROM") == 0)
{
bzero(buff,10240);
printf("\nEnter Sender Email id : ");
scanf("%s",mail_from);
strcpy(buff,"MAIL FROM:<");
strcat(buff,mail_from);
strcat(buff,">");
if(n < 0)
{
}
printf("\nCLIENT : %s",buff); //MAIL FROM:<your email id>
bzero(buff,10240);
if(n < 0)
{
}
printf("SERVER : %s\n",buff); //250 OK
//checking error
code[0] = buff[0];
code[1] = buff[1];
code[2] = buff[2];
code[3] = '\0';
{
}
else{
}
fflush(stdin);
}
else if(strcasecmp(cname,"RCPT TO") == 0)
{
bzero(buff,10240);
printf("\nEnter Recipient Email id : ");
scanf("%s",mail_to);
strcpy(buff,"RCPT TO:<");
strcat(buff,mail_to);
strcat(buff,">");
if(n < 0)
{
}
printf("\nCLIENT : %s",buff); //RCPT TO:<your email id>
bzero(buff,10240);
if(n < 0)
{
}
//checking error
code[0] = buff[0];
code[1] = buff[1];
code[2] = buff[2];
code[3] = '\0';
{
}
else{
}
fflush(stdin);
}
else if(strcasecmp(cname,"DATA") == 0)
{
bzero(buff,10240);
strcpy(buff,"DATA");
if(n < 0)
{
}
printf("\nCLIENT : %s",buff); //DATA
bzero(buff,10240);
if(n < 0)
{
}
printf("SERVER : %s\n",buff); //354 Send message content; end with
<CRLF>.<CRLF>
//checking error
code[0] = buff[0];
code[1] = buff[1];
code[2] = buff[2];
code[3] = '\0';
{
printf("\nReady to send header data!\n\n");
}
else{
}
//creating a mail header
char sub[150];
char content[450];
printf("\nEnter Subject : ");
scanf("%[^\n]",sub);
printf("\nEnter content : (Press Tab and Enter Key to end)\n");
scanf("%[^\t]",content);
bzero(buff,10240);
//Mail_header function declared above
strcpy(buff, Mail_Header(mail_from,mail_to,sub,content)); //assigning header to
buffer
if(n < 0)
{
}
printf("\nCLIENT : ====| Mail header & content |====\n%s\n",buff); //header
content
bzero(buff,10240);
strcpy(buff,".\r\n");
if(n < 0)
{
}
bzero(buff,10240);
if(n < 0)
{
}
//checking error
code[0] = buff[0];
code[1] = buff[1];
code[2] = buff[2];
code[3] = '\0';
{
}
else{
}
fflush(stdin);
}
else if(strcasecmp(cname,"ATTACHMENT") == 0){
bzero(buff,10240);
strcpy(buff,"Attachment");
if(n < 0)
{
}
printf("\nCLIENT : %s",buff); //DATA
bzero(buff,10240);
if(n < 0)
{
}
printf("SERVER : %s\n",buff); //420 send Attachment
code[0] = buff[0];
code[1] = buff[1];
code[2] = buff[2];
code[3] = '\0';
{
printf("\nReady to send image!\n\n");
}
else{
}
send_image(socket_id);
bzero(buff,10240);
if(n < 0)
{
}
printf("SERVER : %s\n\n",buff);
}
else if(strcasecmp(cname,"QUIT") == 0)
{
bzero(buff,10240);
strcpy(buff,"QUIT");
if(n < 0)
{
}
printf("\nCLIENT : %s",buff); //QUIT
bzero(buff,10240);
if(n < 0)
{
}
printf("SERVER : %s\n",buff); //221 Bye
//checking error
code[0] = buff[0];
code[1] = buff[1];
code[2] = buff[2];
code[3] = '\0';
{
printf("\nConnection closed successfully with SMTP Server!\n\n");
}
else{
}
fflush(stdin);
}
else
{
strcpy(cname,"");
goto intake;
}
}while(strcmp(cname,"QUIT") != 0);
}
OUTPUT
Server
Client
File Transfer Protocol
Server Program (ftpsr.c)
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#define BUFSIZE 1024
#define PORT_ADDR 6000
#define QSIZE 5
void main()
{
struct sockaddr_in server_address, client_address;
int i, socket_descriptor_1, socket_descriptor_2, size_of_client_address, file_descriptor,
character_count;
char buffer_1[BUFSIZE], buffer_2[BUFSIZE], pid_str[10];
socket_descriptor_1 = socket(AF_INET, SOCK_STREAM, 0);
server_address.sin_family = AF_INET;
server_address.sin_port = htons(PORT_ADDR);
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
bind(socket_descriptor_1, (struct sockaddr *)&server_address, sizeof(server_address));
listen(socket_descriptor_1, QSIZE);
size_of_client_address = sizeof(client_address);
socket_descriptor_2 = accept(socket_descriptor_1, (struct sockaddr *)&client_address,
&size_of_client_address);
printf("\nRequest accepted.....\n");
close(socket_descriptor_1);
snprintf(pid_str, sizeof(pid_str), "%d", getpid());
character_count = read(socket_descriptor_2, buffer_1, BUFSIZE);
buffer_1[character_count] = '\0';
printf("\nFilename is %s", buffer_1);
if ((file_descriptor = open(buffer_1, O_RDONLY)) >= 0)
{
printf("\nFile opened.....");
character_count = read(file_descriptor, buffer_2, BUFSIZE);
while (character_count > 0)
{
printf("\nSending file.....");
write(socket_descriptor_2, buffer_2, character_count);
printf("\nPrinting content of file:\n");
for (i = 0; i < character_count; i++)
printf("%c", buffer_2[i]);
printf("\n");
if (i == character_count)
break;
}
}
else
{
printf("\nRequested file is not present....!!!\n");
write(socket_descriptor_2, "", 1); // Sending empty response to indicate file not found
}
close(file_descriptor);
write(socket_descriptor_2, pid_str, strlen(pid_str)); // Sending process ID to the client
close(socket_descriptor_2);
}
Client Program (ftpcl.c)

#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
void main()
{
struct sockaddr_in server_address;
int socket_descriptor, character_count, file_length, i;
char buffer_1[3024], buffer_2[3000], pid_str[10];
socket_descriptor = socket(AF_INET, SOCK_STREAM, 0);
server_address.sin_family = AF_INET;
server_address.sin_port = htons(6000);
server_address.sin_addr.s_addr = inet_addr("127.0.0.1");
connect(socket_descriptor, (struct sockaddr *)&server_address, sizeof(server_address));
printf("\nEnter the filename:\n");
character_count = read(0, buffer_1, sizeof(buffer_1));
buffer_1[character_count - 1] = '\0';
write(socket_descriptor, buffer_1, character_count);
file_length = read(socket_descriptor, buffer_2, sizeof(buffer_2));
if (file_length == 0)
printf("\nFile not present....!!!");
else
{
printf("\nPrinting content of file:\n");
for (i = 0; i < file_length; i++)
printf("%c", buffer_2[i]);
printf("\n");
read(socket_descriptor, pid_str, sizeof(pid_str));
printf("Received process ID from server: %s\n", pid_str);
}
close(socket_descriptor);
}
OUTPUT
Server
Client
Leaky Bucket Algorithm
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define NOF_PACKETS 10
int my_rand(int a) {
int rn = (rand() % 10) % a;
return rn == 0 ? 1 : rn;
}
int main() {
int packet_sz[NOF_PACKETS], i, clk, b_size, o_rate, p_sz_rm = 0, p_sz, p_time, op;
for (i = 0; i < NOF_PACKETS; ++i)
packet_sz[i] = my_rand(6) * 10;
for (i = 0; i < NOF_PACKETS; ++i)
printf("\npacket[%d]: %d bytes\t", i, packet_sz[i]);
printf("\nEnter the Output rate: ");
scanf("%d", &o_rate);
printf("Enter the Bucket Size: ");
scanf("%d", &b_size);
for (i = 0; i < NOF_PACKETS; ++i) {
if ((packet_sz[i] + p_sz_rm) > b_size) {
if (packet_sz[i] > b_size)
printf("\n\nIncoming packet size (%d bytes) is greater than bucket capacity (%d
bytes) - PACKET REJECTED", packet_sz[i], b_size);
else
printf("\n\nBucket capacity exceeded - PACKETS REJECTED!!");
} else {
p_sz_rm += packet_sz[i];
printf("\n\nIncoming Packet size: %d", packet_sz[i]);
printf("\nBytes remaining to transmit: %d", p_sz_rm);
p_time = my_rand(4) * 10;
printf("\nTime left for transmission: %d units", p_time);
for (clk = 10; clk <= p_time; clk += 10) {
sleep(1);
if (p_sz_rm) {
if (p_sz_rm <= o_rate)
op = p_sz_rm, p_sz_rm = 0;
else
op = o_rate, p_sz_rm -= o_rate;
printf("\nPacket of size %d transmitted", op);
printf(" ---- Bytes remaining to transmit: %d", p_sz_rm);
} else {
printf("\nTime left for transmission: %d units", p_time - clk);
printf("\nNo packets to transmit!!");
}
}
}}
return 0;
}
OUTPUT
Design and Configuration of Network and Services

Simulation using NS2 Simulator
NS2 Installation in Ubuntu20
------------------------------------
Install
1) sudo apt-get install -y nam
2) sudo apt-get install -y ns2
Check your installation

1) gedit add.tcl
set a 20
set b 30
set c [expr $a+$b]
puts $c
Run in the terminal using ns-2:
ns add.tcl
Output
50
2) Running a simple simulation

gedit simple.tcl
#Create a simulator object
set ns [new Simulator]
#Define different colors for data flows (for NAM)

$ns color 1 Blue
$ns color 2 Red
#Open the NAM trace file set nf [open out.nam w]
$ns namtrace-all $nf
#Define a 'finish' procedure

proc finish {} {
global ns nf
$ns flush-trace
#Close the NAM trace file

close $nf
#Execute NAM on the trace file
exec nam out.nam &
exit 0
}
#Create four nodes

set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
#Create links between the nodes

$ns duplex-link $n0 $n2 2Mb 10ms DropTail
$ns duplex-link $n1 $n2 2Mb 10ms DropTail
$ns duplex-link $n2 $n3 1.7Mb 20ms DropTail
#Set Queue Size of link (n2-n3) to 10
$ns queue-limit $n2 $n3 10
#Give node position (for NAM)

$ns duplex-link-op $n0 $n2 orient right-down
$ns duplex-link-op $n1 $n2 orient right-up
$ns duplex-link-op $n2 $n3 orient right
#Monitor the queue for link (n2-n3). (for NAM)

$ns duplex-link-op $n2 $n3 queuePos 0.5
#Setup a TCP connection

set tcp [new Agent/TCP]
$tcp set class_ 2
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $n3 $sink
$ns connect $tcp $sink
$tcp set fid_ 1
#Setup a FTP over TCP connection

set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ftp set type_ FTP
#Setup a UDP connection

set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
set null [new Agent/Null]
$ns attach-agent $n3 $null
$ns connect $udp $null
$udp set fid_ 2
#Setup a CBR over UDP connection

set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packet_size_ 1000
$cbr set rate_ 1mb
$cbr set random_ false
#Schedule events for the CBR and FTP agents

$ns at 0.1 "$cbr start"
$ns at 1.0 "$ftp start"
$ns at 4.0 "$ftp stop"
$ns at 4.5 "$cbr stop"
#Detach tcp and sink agents (not really necessary)

$ns at 4.5 "$ns detach-agent $n0 $tcp ; $ns detach-agent $n3 $sink"
#Call the finish procedure after 5 seconds of simulation time
$ns at 5.0 "finish"
#Print CBR packet size and interval

puts "CBR packet size = [$cbr set packet_size_]" puts "CBR interval = [$cbr set interval_]"
#Run the simulation

$ns run
Run the simulation from the terminal using ns-2:
ns simple.tcl
Click on the play button to start the simulation:
UDP Datagram in Client-Server Communication using Wireshark

OUTPUT
UDP datagrams
Packet capturing is started. Skype application is also started. This generates UDP
datagrams.
From the trace, the details of frame 47 can be seen. It is an UDP datagram as specified by
column 5.
UDP header has the following fields
source port = 64163 destination port = 3478

Length field = Length of UDP header + Length of data field =
713 bytes checksum =0x9beb
UDP header has a length of 8bytes. The payload of the UDP datagram is therefore 705
bytes whose hexadecimal values are given in the trace.
OUTPUT

NW Lab-1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

NW Lab-1

Uploaded by

Copyright:

Available Formats

fork() System Call

exec() System Call

exit() System Call

wait() System Call

open() and close() System Calls

read() and write() System Call

Client Program (tcpclient.c)

if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

if((n = recvfrom(sock_fd, size, sizeof(size), 0, (struct sockaddr *)&cliaddr, &len)) ==

Client Program (udpclient.c)

// SENDING MATRIX WITH SIZES OF MATRICES 1 AND 2

int sender_seq_bit=0, receiver_seq_bit=0;

if(transmit_seq >= sender_start_seq)

************ OUTPUT IS WITH GO BACK N OUTPUT **********

************ OUTPUT IS WITH UDP CLIENT OUTPUT **********

******* OUTPUT IS WITH READ-WRITE SYSTEM CALL OUTPUT ********

Client Program (smtpclient.c)

Client Program (ftpcl.c)

Design and Configuration of Network and Services

Check your installation

2) Running a simple simulation

#Define different colors for data flows (for NAM)

#Define a 'finish' procedure

#Close the NAM trace file

#Create four nodes

#Create links between the nodes

#Give node position (for NAM)

#Monitor the queue for link (n2-n3). (for NAM)

#Setup a TCP connection

#Setup a FTP over TCP connection

#Setup a UDP connection

#Setup a CBR over UDP connection

#Schedule events for the CBR and FTP agents

#Detach tcp and sink agents (not really necessary)

#Print CBR packet size and interval

#Run the simulation

Click on the play button to start the simulation:

UDP Datagram in Client-Server Communication using Wireshark

source port = 64163 destination port = 3478

You might also like

** OUTPUT IS WITH GO BACK N OUTPUT

** OUTPUT IS WITH UDP CLIENT OUTPUT

* OUTPUT IS WITH READ-WRITE SYSTEM CALL OUTPUT **