St.

Ann's College for Women

(Autonomous), Affiliated To Osmania University
NAAC Reaccredited with 'A+' Grade, College with Potential for Excellence by UGC
Mehdipatnam, Hyderabad -500 028

Department of Computer Science

CSC 616 – SEMESTER VI
Computer NETWORKS
Practical Record

NAME : ……………………………………………………………………………..

HALL TICKET NUMBER: ………………………………………………………

CLASS: B. Sc. III YR ( MECS / MPCS / MSCS)
CSC 616 – SEMESTER VI
Computer NETWORKS
 St. Ann's College for Women
(Autonomous), Affiliated To Osmania University
NAAC Reaccredited with 'A+' Grade, College with Potential for Excellence by UGC
Mehdipatnam, Hyderabad -500 028

Certificate of Completion

This is to certify that ………………………………………

of B. Sc. ( MECS / MPCS/ MSCS) bearing Hall Ticket Number
…………………………………………………………………
has successfully completed the necessary practical record work in

the subject: Computer Networks in Semester VI. Her work has

been duly corrected and certified.

Signature of Internal Examiner Signature of External Examiner

 INDEX

Page
S No Title of Program
Nos
1 Write a program to create socket and implement socket function
2 Write a program to get MAC Address
3 Write a program to display hello world using signals
4 Write a program for socket pair system call using IPC
Write a program to implement Sliding Window Protocol
5

Write a Program to identify the category of IP Address for a

6
given IP Address
7 Write a program to print details of DNS Host
8 Write a program to implement listener and talker
Write a program to implement TCP echo using client server
9
program
Write a program to implement UDP Echo using client server
10
program
Write a UDP client server program to convert lowercase letters
11
to uppercase letters
Write a TCP Client Server program to convert a given string into
12
reverse
Write a UDP Client server program to convert given string into
13
reverse
Write a program to implement TCP Iterative client server
14
program
Write a program to implement time service using TCP client
15
server program
Write a program to implement time service using UDP client
16
server program
1. Write a program to create socket and implement socket function

Server side Code – server1.c

#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#define PORT 8080
int main(int argc, char const *argv[])
{
int server_fd, new_socket, val;
struct sockaddr_in address;
int opt = 1;
int l= sizeof(address);
char bfr[1024] = {0};
char *hello = "Hello from server";
if((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
{
perror("socket failed");
exit(EXIT_FAILURE);
}

if(setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,

&opt, sizeof(opt)))
{
perror("setsockopt");
exit(EXIT_FAILURE);
}

address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
if(bind(server_fd, (struct sockaddr *)&address, sizeof(address))<0)
{
perror("bind failed");
exit(EXIT_FAILURE);
}
if (listen(server_fd, 3) <0)
{
perror("listen");
exit(EXIT_FAILURE);
}
if((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&l))<0)
{
perror("accept");
exit(EXIT_FAILURE);
}

val = read( new_socket , bfr, 1024 );

printf("%s\n",bfr);
send(new_socket,hello,strlen(hello),0);
printf("Hello message sent\n");
return 0;
}

Client side Code – client1.c

#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#define PORT 8080
int main(int argc, char const *argv[])
{

struct sockaddr_in address;

int s = 0, val;
struct sockaddr_in server_address;
char *hello = "Hello from client";
char bfr[1024] = {0};
if((s = socket(AF_INET, SOCK_STREAM, 0)) <0)
{
printf("\n Socket creation error \n");
return - 1;
}
memset(&server_address, '0', sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_port = htons(PORT);
if(inet_pton(AF_INET, "127.0.0.1", &server_address.sin_addr)<=0)
{
printf("\nInvalid address/ Address not supported \n");
return - 1;
}

if(connect(s, (struct sockaddr *)&server_address, sizeof(server_address)) <0)

{
printf("\nConnection Failed \n");
return -1;
}

send(s, hello, strlen(hello) , 0 );

printf("Hello message sent\n");
val = read(s, bfr, 1024);
printf("%s\n",bfr );
return 0;
}

Output:
2. Write a program to get MAC Address

Code – macaddr.c

#include <stdio.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<errno.h>
#include<string.h>
#include<stdlib.h>
#include<sys/ioctl.h>
#include<fcntl.h>
#include<unistd.h>
#include<net/if.h>

void getMacAddress(char * uc_Mac)

{
int fd;
struct ifreq ifr;
char *iface = "eth0";
char *mac;
fd = socket(AF_INET, SOCK_DGRAM, 0);
ifr.ifr_addr.sa_family = AF_INET;
strncpy((char *)ifr.ifr_name , (const char *)iface, IFNAMSIZ-1);
ioctl(fd, SIOCGIFHWADDR,&ifr);
close(fd);
mac = (char *)ifr.ifr_hwaddr.sa_data;
sprintf((char *)uc_Mac,(const char *) "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n" ,mac[0],
mac[1], mac[2], mac[3], mac[4], mac[5]);
}
int main()
{
char mac[32]={0};
getMacAddress (mac);
printf("\nMacAddress : %s" ,mac);
return 0;
}

OUTPUT:
Program 3 – Write a program to display hello world using signals

helloworld.c

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<signal.h>

void sighandler(int);
int main()
{
signal(SIGINT, sighandler);
while(1)
{
printf("Hello World\n");
sleep(2);
}
return(0);
}

void sighandler(int signum)

{
exit(1);
}

OUTPUT:
Program 4 – Write a program for socket pair system call using IPC

socketpair.c

#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#define DATA1 "WELCOME TO ST.ANNS"
#define DATA2 "Computer Netwroks is an awesome subject"
int main()
{
int sockets[2],ch;
char buffer[1024];
if(socketpair(AF_UNIX,SOCK_STREAM,0,sockets)<0)
{
perror("opening stream socket pair");
exit(1);
}
if((ch=fork())== -1)
perror("fork");
else if(ch)
{
close(sockets[0]);
if(read(sockets[1],buffer,sizeof(buffer))<0)
perror("reading stream message");
printf("-->%s\n",buffer);
if(write(sockets[1],DATA2, sizeof(DATA2))<0)
perror("wriring stream messages");
close(sockets[1]);
}
else
{
close(sockets[1]);
if(write(sockets[0],DATA1, sizeof(DATA1))<0)
perror("writing stream message");
if(read(sockets[0], buffer, sizeof(buffer))<0)
perror("reading stream messages");
printf("-->%s\n",buffer);
close(sockets[0]);
}
return 0;
}
OUTPUT:
Program 5 – Write a program to implement Sliding Window Protocol

slidingwindow.c

#include<stdio.h>
int main()
{
int w_size, i,fr, frames[50];
printf("enter the size of the window");
scanf("%d",&w_size);
printf("/n enter number of frames to transmit");
scanf("%d",&fr);
printf("\n enter %d frames:",fr);
for(i=1; i<=fr;i++)
scanf("%d",&frames[i]);
printf("\n Transmission of frames as per sliding window");
printf("after sending %d frames at each stage , sender waits for acknowledgement
from receiver",w_size);
for(i=1;i<=fr; i++)
{
if(i%w_size==0)
{
printf("%d\n",frames[i]);
printf("Acknowledgement of frames received by sender \n");
}
else
printf("%d \n",frames[i]);
}
if(fr%w_size!=0)
printf("\n acknowledgement of above frames received by sender");
return 0;
}
OUTPUT:
Program 6 – Write a Program to identify the category of IP Address for a given
IP Address

ipaddrprg.c

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
void getIpAddress(unsigned char *source_String, short *ip)
{
unsigned short l =0;
unsigned char oct[4] = {0}, cnt =0, cnt1 = 0, i, buf[5];
l = strlen(source_String);

for (i =0; i<l; i++)

{
if(source_String[i]!='.')
{
buf[cnt++] = source_String[i];
}

if(source_String[i] =='.' || i ==l-1)

{
buf[cnt] = '\0';
cnt =0;
oct[cnt1++] = atoi(buf);
}
}
ip[0] = oct[0];
ip[1] = oct[1];
ip[2] = oct[2];
ip[3] = oct[3];

int main()
{
unsigned char ip_Address[20] = {0};
short ip[4];
printf("Enter IP Address in xxx.xxx.xxx.xxx format: ");
scanf("%s",ip_Address);
getIpAddress(ip_Address, &ip[0]);
printf("\n IP Address: %03d.%03d.%03d.%03d\n",ip[0],ip[1],ip[2],ip[3]);
if (ip[0]>=0&&ip[0]<127)
printf("Class A IP Address\n");
if (ip[0]>127 && ip[0] <191)
printf("Class B IP Address\n");
if(ip[0]>191 && ip[0] < 224)
printf("Class C Ip Address");
if(ip[0]>224 && ip[0] <=239)
printf("Class D IP Address");
if(ip[0]>239)
printf("Class E Address");
return 0;
}

OUTPUT:
Program 7 – Write a program to print details of DNS Host

dnshost.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<netdb.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
void checkHostName(int h_name)
{
if(h_name == -1)
{
perror("gethostname");
exit(1);
}
}
void checkHostEntry(struct hostent *h_entry)
{
if(h_entry == NULL)
{
perror ("gethostbyname");
exit(1);

}
}

void checkIPbuffer( char *IPbuffer)

{
if (NULL == IPbuffer)
{
perror("inet_ntoa");
exit(1);
}
}

int main()
{
char h_buffer[256];
char *IPbuffer;
struct hostent *host_entry;
int h_name;
h_name = gethostname(h_buffer, sizeof(h_buffer));
checkHostName(h_name);
host_entry = gethostbyname(h_buffer);
checkHostEntry(host_entry);
// converting internet network address into ASCII string
IPbuffer = inet_ntoa(*((struct in_addr*)host_entry->h_addr_list[0]));
printf("Host Name : %s\n", h_buffer);
printf("Host IP: %s\n", IPbuffer);
return 0;
}

OUTPUT:
Program 8 – Write a program to implement listener and talker

Server side code – listener.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#define PORT "4950"
#define SIZE 100

void *get_in_addr(struct sockaddr *sa)

{
if(sa->sa_family == AF_INET)
{

return &(((struct sockaddr_in*)sa)->sin_addr);

}
return &(((struct sockaddr_in6*)sa)->sin6_addr);
}

int main(void)
{
int fd;
struct addrinfo hints, *servinfo, *p;
int rv, numbytes;
struct sockaddr_storage their_addr;
char bfr[SIZE];
socklen_t l;
char s[INET6_ADDRSTRLEN];
memset(&hints, 0 , sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE;
if((rv = getaddrinfo(NULL, PORT, &hints, &servinfo))!=0)
{
fprintf(stderr,"getaddrinfo:%s\n", gai_strerror(rv));
return 1;
}
for (p = servinfo; p!=NULL; p = p->ai_next)
{
if (( fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
{
perror("listener:socket");
continue;
}

if(bind(fd,p->ai_addr, p->ai_addrlen ) == -1)

{
close(fd);
perror("listener:bind");
continue;
}
break;
}
if(p ==NULL)
{
fprintf(stderr,"listener:failed to bind socket\n");
return 2;
}

freeaddrinfo(servinfo);
printf("listener: waiting to receive from..\n");
l = sizeof their_addr;
if((numbytes = recvfrom(fd,bfr,SIZE-1,0, (struct sockaddr*)&their_addr,&l))== -1)
{
perror("recvfrom");
exit(1);
}

printf("listener: got packet from %s\n",

inet_ntop(their_addr.ss_family,get_in_addr((struct sockaddr*)&their_addr),s,sizeof
s));
printf("listener: packet is %d bytes long\n", numbytes);
bfr[numbytes] = '\0';
printf("listener: packet contains %s\n",bfr);
close(fd);
return 0;
}

client side code – client.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#define SERVERPORT "4950"
int main(int argc, char *argv[])
{
int fd;
struct addrinfo hints, *servinfo, *p;
int rv, numbytes;
if(argc != 3)
{
fprintf(stderr, "Usage: Talker hostname message\n");
exit(1);
}

memset(&hints,0, sizeof hints);

hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if((rv = getaddrinfo(argv[1], SERVERPORT, &hints, &servinfo)) !=0)
{
fprintf (stderr,"getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}

for(p = servinfo; p!= NULL; p = p->ai_next)

{
if((fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
{
perror ("talker:socket");
continue;

break;
}

if(p==NULL)
{
fprintf(stderr,"talker: failed to create socket\n");
return 2;
}

if((numbytes = sendto(fd, argv[2],strlen(argv[2]),0,p->ai_addr,p->ai_addrlen)) == -1)

{
perror("talker: sendto");
exit(1);
}

freeaddrinfo(servinfo);
printf("talkee: sent %d bytes to %s\n", numbytes, argv[1]);
close(fd);
return (0);
}

OUTPUT:
Program 9 – Write a program to implement TCP echo using client server
program

client side code: tcpechoclient.c

#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<strings.h>
#define MAX_MSG 100
#define SERVER_ADDR "127.0.0.1"
#define CLIENT_ADDR "127.0.0.1"
#define SERVER_PORT 3786
#define CLIENT_PORT 8229
int main()
{
int sd, rc, i, n;
struct sockaddr_in client_Addr, serv_Address;
char line[MAX_MSG], line_r[MAX_MSG];
bzero((char *)&serv_Address, sizeof(serv_Address));
serv_Address.sin_family = AF_INET;
serv_Address.sin_addr.s_addr = inet_addr(SERVER_ADDR);
serv_Address.sin_port = htons(SERVER_PORT);

bzero((char *)&client_Addr, sizeof(client_Addr));

client_Addr.sin_family = AF_INET;
client_Addr.sin_addr.s_addr = INADDR_ANY;
client_Addr.sin_port = htons(0);
sd = socket(AF_INET, SOCK_STREAM,0);
printf("Stream socket created successfully\n");
bind(sd, (struct sockaddr *)&client_Addr, sizeof(client_Addr));
printf("bound local port successfully\n");
connect(sd, (struct sockaddr *)&serv_Address, sizeof(serv_Address));
printf("Connected to server\n");
do
{
printf("enter a string to send to server");
scanf("%s", line);
send(sd,line,strlen(line) +1 , 0);
printf("data sent is : %s\n", line);
n = recv(sd, line_r, MAX_MSG,0);
line_r[n] = '\n';
printf("received from server [IP %s , TCP Port %d]: %s\n",
inet_ntoa(serv_Address.sin_addr), ntohs(serv_Address.sin_port),line_r);
} while (strcmp(line,"quit"));
printf("terminating connection with server\n");
close(sd);
return 0;
}

server side program – tcpechoserver.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
#include<unistd.h>
#include<strings.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#define MAX_MSG 100

#define SERVER_ADDR "127.0.0.1"

#define SERVER_PORT 3786
int main()
{
int sd, newSd, cliLen, n;
struct sockaddr_in client_Address, server_Address;
char line[MAX_MSG], line_r[MAX_MSG];
bzero((char *)&server_Address, sizeof(server_Address));
server_Address.sin_family = AF_INET;
server_Address.sin_addr.s_addr = inet_addr(SERVER_ADDR);
server_Address.sin_port = htons(SERVER_PORT);
sd = socket(AF_INET, SOCK_STREAM, 0);
printf("Stream socket created successfully\n");
bind(sd,(struct sockaddr* )&server_Address, sizeof(server_Address));
printf("bound local port successfully\n");
listen(sd,5);
while(1)
{

printf("waiting for client connection on port TCP %u\n",SERVER_PORT);

cliLen = sizeof(client_Address);
newSd = accept(sd, (struct sockaddr *)&client_Address, &cliLen);
printf( "Received Connection from host[IP %s , TCP Port %d]\n",
inet_ntoa(client_Address.sin_addr), ntohs(client_Address.sin_port));

do
{
memset(line, 0x0, MAX_MSG);
n = recv(newSd, line, MAX_MSG,0);

line[n] = '\n';

printf("Received from host[IP %s , TCP port %d]: %s\n",

inet_ntoa(client_Address.sin_addr), ntohs(client_Address.sin_port),line);
strcpy(line_r, line);
send(newSd, line_r, strlen(line_r) + 1, 0);

printf("data echoed is :%s\n", line_r);

} while(abs(strcmp(line, "quit")));
printf( "Terminating connection with host [IP %s , TCP Port %d] \n",
inet_ntoa(client_Address.sin_addr),ntohs(client_Address.sin_port));
close(newSd);
}
return 0;
}
OUTPUT:
Program10 – Write a program to implement UDP Echo using client server
program

client side code – udpechoclient.c

#include<arpa/inet.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<unistd.h>
int main()
{
const char* server_name = "localhost";
const int server_port = 8877;
struct sockaddr_in server_address;
memset(&server_address,0,sizeof(server_address));
server_address.sin_family = AF_INET;
inet_pton(AF_INET,server_name, &server_address.sin_addr);
server_address.sin_port = htons(server_port);
int s;
if((s = socket(PF_INET, SOCK_DGRAM,0))<0)
{
printf("socket cannot be created\n");
return 1;
}
const char* data_to_send = "St. ANn's College";
int l = sendto(s, data_to_send, strlen(data_to_send), 0, (struct
sockaddr*)&server_address, sizeof(server_address));
char bfr[100];
recvfrom(s,bfr,l,0,NULL,NULL);
bfr[1] = '\0';
printf("received : %s\n", bfr);
close(s);
return 0;
}

serverside code - udpechoserver.c

#include<arpa/inet.h>
#include<netinet/in.h>
#include<stdbool.h>
#include<stdio.h>
#include<string.h>
int main(int argc, char* argv[])
{
int SERVER_PORT = 8877;
struct sockaddr_in server_address;
memset(&server_address,0,sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_port = htons(SERVER_PORT);
server_address.sin_addr.s_addr = htonl(INADDR_ANY);
int s;
if((s = socket(PF_INET, SOCK_DGRAM,0)) <0)
{
printf("could not create socket\n");
return 1;
}
if((bind(s, (struct sockaddr*)&server_address, sizeof(server_address)))<0)
{
printf("could not bind socket\n");
return 1;
}

struct sockaddr_in client_address;

int client_address_len =0;
while(true)

{
char bfr[500];
int l = recvfrom(s, bfr, sizeof(bfr), 0, (struct sockaddr* )&client_address,
&client_address_len);
bfr[l] = '\0';
printf(" received : %s from client %s\n" , bfr, inet_ntoa(client_address.sin_addr));

sendto(s, bfr, l, 0, (struct sockaddr* )&client_address, sizeof(client_address));

}
return 0;
}
OUTPUT:
Program 11 – Write a UDP client server program to convert lowercase letters to
uppercase letters

client side code – upperclient.c

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<arpa/inet.h>
int main()
{
int cli_Socket, portNum, nBytes;
char bfr[1024];
struct sockaddr_in serverAddr;
socklen_t addr_size;
cli_Socket = socket(PF_INET, SOCK_STREAM, 0);
portNum = 7891;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(portNum);
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);
addr_size = sizeof serverAddr;
connect(cli_Socket, (struct sockaddr *)&serverAddr, addr_size);
while(1)
{
printf("enter the data to send to server\n");
fgets(bfr, 1024, stdin);
printf("Data sent is : %s", bfr);
nBytes = strlen(bfr)+1;
send(cli_Socket, bfr, nBytes, 0);
recv (cli_Socket, bfr, 1024, 0);
printf(" data received from server is : %s\n", bfr);
}
return 0;
}

server side code – upperserver.c

include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string.h>
#include<stdlib.h>
#include<arpa/inet.h>
#include<ctype.h>
#include<unistd.h>
int main()
{
int wlcm_Sock, new_Sock, portNum, cli_Length, nBytes;
char bfr[1024];
struct sockaddr_in serverAddr;
struct sockaddr_storage serverStorage;
socklen_t addr_size;
int i;
wlcm_Sock = socket(PF_INET, SOCK_STREAM,0);
portNum = 7891;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(portNum);
serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);
bind(wlcm_Sock, (struct sockaddr*) &serverAddr, sizeof(serverAddr));
if(listen(wlcm_Sock,5 ) == 0)
printf("Listening\n");
else
printf("Error\n");
addr_size = sizeof serverStorage;
while(1)
{
new_Sock = accept(wlcm_Sock, (struct sockaddr*) &serverStorage, &addr_size);
if(!fork())
{
nBytes =1;
while(nBytes !=0)
{
nBytes = recv(new_Sock, bfr, 1024,0);
for(i=0; i <nBytes-1; i++)
{
bfr[i] = toupper(bfr[i]);
}

send(new_Sock, bfr, nBytes, 0);

}
close(new_Sock);
exit(0);
}
else
{
close(new_Sock);
}
}
return 0;
}

OUTPUT:
Program 12 – Write a TCP Client Server program to convert a given string into
reverse

client side code – stringclient.c

#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#define MAXLINE 20
#define SERV_PORT 5777
int main(int argc, char* argv)
{
char str1[MAXLINE], str2[MAXLINE];
int s;
struct sockaddr_in server_address;
s = socket(AF_INET, SOCK_STREAM, 0);
bzero(&server_address, sizeof(server_address));
server_address.sin_family = AF_INET;
server_address.sin_port = ntohs(SERV_PORT);
connect(s ,(struct sockaddr*)&server_address, sizeof(server_address));
printf("\n Enter data to be sent");
while(fgets(str1, MAXLINE, stdin)!=NULL)
{
write(s, str1, strlen(str1));
printf("\n data sent to server: ");
read(s, str2, MAXLINE);
printf("\n The Reverse of given string is %s", str2);
printf("\n");
}
return 0;
}

Server side code – stringserver.c

#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<sys/types.h>
#define MAXLINE 20
#define SERV_PORT 5777
int main(int argc, char* argv)
{
int i, j;
ssize_t n;
char str1[MAXLINE], str2[MAXLINE];
int listenfd, connfd, l;
struct sockaddr_in servaddr, cliaddr;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr));
listen(listenfd, 1);
for( ; ; )
{
l = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr*)&cliaddr, &l);
printf("connect to client");
while(1)
{
if((n = read(connfd, str1,MAXLINE )) ==0)
break;
str1[n-1] = '\0';
j = 0;
for(i = n-2; i>=0; i--)
str2[j++] = str1[i];
str2[j] = '\0';
write(connfd, str2, n);
}
}
return 0;
}
OUTPUT:
Program 13 – Write a UDP Client server program to convert given string into
reverse

client code – udpstringclient.c

#include<stdio.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<unistd.h>
#define PORT 8090
int main()
{
struct sockaddr_in address;
int s=0, val;
struct sockaddr_in serv_addr;
char strng[100];
printf("\n Enter the string");
scanf("%[^\n]s",strng);

char bfr[1024] = {0};

if((s = socket(AF_INET, SOCK_STREAM, 0))<0)
{ printf("\n Socket creation error");
return -1;
}
memset(&serv_addr, '0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0)
{
printf("\n address not supported");
return -1;
}
if(connect ( s, (struct sockaddr*)&serv_addr, sizeof(serv_addr))<0)
{
printf("\n conection failed");
return -1;
}

int l = strlen(strng);
send(s, strng, sizeof(strng), 0);
val = read(s, strng, l);
printf( "%s\n",strng);
return 0;
}

server side code – udpstringserver.c

#include<netinet/in.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#define PORT 8090
int main()
{
int server_fd, new_socket, val;
struct sockaddr_in addr;
char strng[100];
int addrlen = sizeof(addr);
char bfr[1024] = {0};
char* hello = "Hello from Server";
if((server_fd = socket(AF_INET, SOCK_STREAM, 0)) ==0)
{
perror("socket failed");
exit(EXIT_FAILURE);
}
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(PORT);
if(bind(server_fd, (struct sockaddr*)&addr, sizeof(addr))<0)
{
perror ("bind failed");
exit (EXIT_FAILURE);
}
if(listen(server_fd,3)<0)
{
perror("listen");
exit(EXIT_FAILURE);
}
if((new_socket =accept(server_fd, (struct sockaddr*)&addr,
(socklen_t*)&addrlen))<0)
{
perror("accept");
exit(EXIT_FAILURE);
}
val = read(new_socket, strng, sizeof(strng));
int i, j, temp;
int l = strlen(strng);
printf("\n string sent by client : %s \n" , strng);
for(i=0, j=l-1; i<j; i++, j--)
{
temp = strng[i];
strng[i] = strng[j];
strng[j] = temp;
}
send(new_socket, strng, sizeof(strng),0);
printf("\n Modified string sent to client \n");
return 0;

OUTPUT:
Program 14 – Write a program to implement TCP Iterative client server
program

server side code – iterativeserver.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<unistd.h>
#define PORT 8000
#define SIZE 100
int main()
{
int s;
int newsockfd;
struct sockaddr_in server_Address;
struct sockaddr_in client_Address;
int n;

char str[SIZE];
int l;
s= socket(AF_INET,SOCK_STREAM,0);
memset(&server_Address, 0, sizeof(server_Address));
server_Address.sin_family = AF_INET;
server_Address.sin_addr.s_addr = htonl(INADDR_ANY);
server_Address.sin_port = htons(PORT);
bind(s, (struct sockaddr*)&server_Address, sizeof(server_Address));
listen(s,5);
while(1)
{
printf("\n Waiting for Connection \n");
l = sizeof(client_Address);
newsockfd = accept(s, (struct sockaddr*)&client_Address, &l);
while(1)
{
n = recv(newsockfd,str,SIZE,0);
if(n == 0)
{
close(newsockfd);
break;
}
str[n] = 0;
send(newsockfd, str, n, 0);
printf("Receive and set data to: %s\n", str);

return 0;

client side program -

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<string.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#define PORT 8000
#define SERVER_IP "127.0.0.1"
#define SIZE 100
int main()
{

int s;
struct sockaddr_in server_Address;
int n;
char str1[SIZE];
char str2[SIZE];
s = socket(AF_INET, SOCK_STREAM, 0);
memset(&server_Address, 0, sizeof(server_Address));
server_Address.sin_family = AF_INET;
server_Address.sin_addr.s_addr = inet_addr(SERVER_IP);
server_Address.sin_port = htons(PORT);
connect(s, (struct sockaddr*)&server_Address, sizeof(server_Address));
while(1)
{
printf("\n Enter message to send to server\n");
fgets(str1, SIZE, stdin);
if(str1[0] == '#')
break;
n = strlen(str1)+1;
send(s, str1, n, 0);
n = recv(s, str2, SIZE, 0);
printf("The message received from server is : %s", str2);
}
return 0;
}

OUTPUT:
Program 15 – Write a program to implement time service using TCP client
server program

server side code – tcptimeserver.c

#include<netinet/in.h>
#include<sys/socket.h>
#include<stdio.h>
#include<string.h>
#include<time.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{

struct sockaddr_in socket_address;

struct sockaddr_in cli;
int s, conntfd;
int l, ch;
char str[100];
time_t tick;
s = socket(AF_INET, SOCK_STREAM, 0);
if(s<0)
{
printf("error in socket\n");
exit(0);
}
else

printf("Socket opened\n");
bzero(&socket_address, sizeof(socket_address));
socket_address.sin_port = htons(5600);
socket_address.sin_addr.s_addr = htonl(0);
if(bind(s, (struct sockaddr*)&socket_address, sizeof(socket_address))<0)
{
printf("Error in binding");
}
else

printf("Binded Successfully\n");
listen(s,50);
for( ; ; )
{
l = sizeof(ch);
conntfd = accept(s, (struct sockaddr*)&cli, &l);
printf("Accepted\n");
tick = time(NULL);
snprintf(str, sizeof(str), "%s", ctime(&tick));
printf("%s", str);
write(conntfd, str, 100);
}
return 0;
}

client side code - tcptimeclient.c

#include<stdio.h>
#include<netinet/in.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<strings.h>
#include<sys/types.h>
#include<unistd.h>
int main()
{

struct sockaddr_in socket_address, cli;

int n, s;
char bfr[100];
s = socket(AF_INET, SOCK_STREAM, 0);
if(s<0)
{
printf("\n Error in Socket");
exit(0);
}

else
printf("\n Socket is opened");
bzero(&socket_address, sizeof(socket_address));
socket_address.sin_family = AF_INET;
socket_address.sin_port = htons(5600);
if(connect(s, (struct sockaddr*)& socket_address, sizeof(socket_address))<0)
{
printf("\n COnnection failed");
exit(0);
}

else
printf("\n COnnected succesfully");
if (n = read(s, bfr, sizeof(bfr))<0)
{
printf("\n Error in reading");
exit(0);
}
else
{
printf("\nMessage Read %s", bfr);
}
return 0;
}

OUTPUT:
Program 16 – write a program to implement time service using UDP client
server program

server side program – udptimeserver.c

#include<stdio.h>
#include<string.h>

#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<time.h>
int main()
{
char bfr[1024];
int sfd, r, bi, port;
struct sockaddr_in server_address, client_address;
socklen_t l;
sfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sfd == -1)

perror("Socket");
return 0;
}

printf("\n ENter Port No");

scanf("%d", &port);
printf("the port no is %d\n",port);
server_address.sin_family=AF_INET;
server_address.sin_port = htons(port);
server_address.sin_addr.s_addr = INADDR_ANY;
bi = bind(sfd, (struct sockaddr*)&server_address, sizeof(server_address));

if(bi== -1)
{
perror("Bind()");
return 0;
}
l = sizeof(client_address);
r = recvfrom(sfd, bfr, sizeof(bfr), 0, (struct sockaddr*)&client_address, &l);
bfr[r] = 0;
time_t ticks;
ticks = time(NULL);
snprintf(bfr, sizeof(bfr), "%24s\r\n",ctime(&ticks));
sendto(sfd, bfr, sizeof(bfr), 0, (struct sockaddr*)&client_address,
sizeof(client_address));
exit(0);
return 0;
}

client side code – udptimeclient.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
int main()
{

char bfr[1024];
int listenfd, port, r;
struct sockaddr_in server_address, client_address;
socklen_t l;
listenfd = socket(AF_INET, SOCK_DGRAM, 0);
if(listenfd == -1)
{
perror("Socket");
return 0;
}

printf("\n Enter Port no" );

scanf("%d", &port);
printf(" the port number is %d ", port);
server_address.sin_family = AF_INET;
server_address.sin_port = htons(port);
server_address.sin_addr.s_addr = INADDR_ANY;
sendto(listenfd, bfr, sizeof(bfr), 0, (struct sockaddr*)&server_address,
sizeof(server_address));
r = recvfrom(listenfd, bfr, sizeof(bfr), 0, (struct sockaddr*)&server_address, &l);
bfr[r] = 0;
printf("\n The time received from server is: %s\n",bfr);
exit(0);
return 0;
}
OUTPUT:
Program 1 Output:

Program 2 _ MAC Address

Program 3 – Print hello world using signals

Program 4 - Program for socket pair system using IPC

Program 5 : slidingwindow.c – OUTPUT

Program 6

ipaddrprg.c – OUTPUT
Program 7 – dnshost.c – OUTPUT

Program 8 – Program to implement listener and talker

Program 9 – Implement TCP echo using client server program

Program 10 – Implement UDP echo using client server program

program 11 – UDP Client server program to convert lowercase letters to upper case letters
Program 12 – TCP Client Server Program to convert a given string into reverse

Program 13 –
Write a UDP Client server program to convert given string into reverse
Program 14 – Write a program to implement TCP iterative client-server program

Program 15 - Write a program to implement time service using TCP client server program
Program 16 – Program to implement time service using UDP client server program