Q1.

UDP_Time

SERVER
Code:-

#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<time.h>
time_t ticks;
int main()
{
struct sockaddr_in serv_addr, cli_addr;

int skfd, r, s, cli_addr_len;

int short serv_port = 25020; /*port number to be used by the server*/

char serv_ip[] = “127.0.0.1”; /* server’s IP address*/

char buff[128]; /*buffer for sending and receiving messages */

/*initializing server socket address structure with zero values*/

bzero(&serv_addr, sizeof(serv_addr));

/*filling up the server socket address structure with appropriate

values*/

serv_addr.sin_family = AF_INET; /*address family*/

serv_addr.sin_port = htons(serv_port); /*port number*/

inet_aton(serv_ip,(&serv_addr.sin_addr)); /*IP address*/

printf("\n UDP TIME SERVER.\n");

/*creating socket*/

if((skfd= socket(AF_INET,SOCK_DGRAM,0)) < 0)

printf("\n SERVER ERROR: cannot create socket.\n");

exit(1);

/*binding server socket address structure*/

if((bind(skfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))) < 0)

{
 printf("\n SERVER ERROR: Cannot Bind\n");

close(skfd);

exit(1);

for( ; ; )

/*server waits, till client sends any message to be received*/

printf("\n SERVER: Waiting for client...Press Ctrl + c to stop

server:\n");

cli_addr_len = sizeof(cli_addr);

if((r = recvfrom(skfd, buff, 128, 0, (struct sockaddr*)&cli_addr,

&cli_addr_len)) < 0)

printf("\n SERVER: Cannot receive");

close(skfd);

exit(1);

buff[r] = '\0';

ticks = time(NULL);

snprintf(buff, 128, “%s”, ctime(&ticks));

if((s = sendto(skfd, buff, 128, 0, (struct sockaddr*)&cli_addr,

cli_addr_len)) < 0)

printf(“\n SERVER ERROR: Cannot send.\n”);

close(skfd);

exit(1);

printf(“\n SERVER: Message send to client %s: %s.\n” ,

inet_ntoa(cli_addr.sin_addr, buff); /*sent s bytes to

client*/

}//for ends

}//main ends
CLIENT
Code:-
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<time.h>
time_t ticks;
int main()
{
struct sockaddr_in serv_addr;

int skfd, r, s, serv_addr_len;

int short serv_port = 25020; /*port number used by server*/

char serv_ip[] = “127.0.0.1”; /*server’s IP address*/

char buff[128]; /*buffer for sending and receiving messages*/

/* initializing server socket address structure with zero values*/

bzero(&serv_addr, sizeof(serv_addr));

/* filling up the server socket address structure with appropriate

values*/

serv_addr.sin_family = AF_INET; // address family

serv_addr.sin_port = htons(serv_port); // port number

inet_aton(serv_ip, (&serv_addr.sin_addr)); // IP address

printf(“\n UDP TIME CLIENT.\n”);

/*creating socket*/

if((skfd= socket(AF_INET, SOCK_DGRAM,0)) < 0)

printf("\n CLIENT ERROR: Cannot create socket.\n");

exit(1);

/*sending message to the echo server*/

if((s = sendto(skfd, buff, 128, 0, (struct sockaddr*)&serv_addr,

sizeof(serv_addr))) < 0)
 {

printf(“\n CLIENT ERROR: Cannot send.\n”);

close(skfd);

exit(1);

serv_addr_len = sizeof(serv_addr);

if((r = recvfrom(skfd, buff, 128, 0, (struct sockaddr*)&serv_addr,

&serv_addr_len)) < 0)

printf(“\n CLIENT ERROR: Cannot receive.\n”);

close(skfd);

exit(1);

rbuff[r] = ‘\0’;

/*received ‘r’ bytes from server*/

printf(“\n CLIENT: Time received from server: %s.\n “,buff);

close(skfd);

exit(1);

}// main ends

}

Output:

Q2. TCP_Echo
Server

Code:

#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
struct sockddr_in serv_addr, cli_addr;
int listenfd, connfd r, w, cli_aadr_len, val;
unsigned short serv_port= 25020; /* port number to be used by the
server*/
char serv_ip [] = “127.0.0.1”; /* server’s IP-address */
char buff [128]; /* buffer for sending and receiving messages*/
int main()
{
/* initializing server socket address structure with zero values
*/

bzero (&serv_addr, sizeof(serv_addr));

/*filling up the server socket address structure with appropriate

values*/

serv_addr.sin_family = AF_INET; /*address family*/

serv_addr.sin_port = htons(serv_port); /*port number*/

inet_aton(serv_ip, (&serv_addr.sin_addr)); /*IP-address*/

printf(“\n TCP ECHO SERVER \n”);

/*creating socket*/

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

printf(“\n SERVER ERROR: Cannot create socket. \n”);

exit(1);

/*binding server socket address structure*/

 if(( bind(listenfd, (struct sockaddr*)&serv_addr,
sizeof(serv_addr))) < 0)

printf("\n SERVER ERROR: Cannot bind\n");

close(listenfd);

exit(1);

/*listen to client connection requests*/

if((listen(listenfd,5)) < 0)

printf(“\n SERVER ERROR: Cannot listen \n ”);

close(listenfd);

exit(1);

cli_addr_len = sizeof(cli_addr);

for(; ;)

printf(“\n SERVER: Listening for clients…… Press Cntrl + C

to stop echo server. \n”);

/*accept client connections */

if((connfd = accept (listenfd, (struct sockaddr*)&cli_addr,

&cli_addr_len)) < 0)

printf(“\n SERVER ERROR: Cannot accept client

connections. \n ”);

close(listenfd);

exit(1);

printf(“\n SERVER: Connection from client %s accepted. \n”,

inet_ntoa(cli_addr.sin_addr));

/*waiting for messages from client*/

if(( r = read (connfd, buff, 128)) < 0)

printf(“\n SERVER ERROR: Cannot receive message from client.

\n”);
 else

buff[r] = ‘\0’;

/*echo back the messages received from client*/

if(( w = write(connfd, buff, 128)) < 0 )

printf(“\n SERVER ERROR: Cannot send message to

the client \n”);

else

printf(“\n SERVER: Echoed back to %s to %s \n”, buff,

inet_ntoa(cli_addr.sin_addr));

} /* for ends */

} /* main ends */

CLIENT
Code:-
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
struct sockddr_in serv_addr;
int skfd, r, w;
unsigned short serv_port= 25020; /*port number used by the server*/
char serv_ip[]= “127.0.0.1”; /*server’s IP-address*/
char rbuff [128]; /*buffer for receiving messages*/
char sbuff [128] = “HELLO SERVER”; /*buffer for sending messages*/
int main ()
{
/*initializing server socket address structure with zero values*/
bzero(&serv_addr, sizeof(serv_addr));

/*filling up the server socket address structure with appropriate

values*/
serv_addr.sin_family = AF_INET; /*address family*/

serv_addr.sin_port = htons(serv_port); /*port number*/

inet_aton(serv_ip, (&serv_addr.sin_addr)); /*IP-address*/

printf(“\n TCP ECHO CLIENT \n”);

/*creating socket*/

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

printf(“\n SERVER ERROR: Cannot create socket. \n”);

exit(1);

/*request server for a connection*/

if(( connect(skfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))) < 0

)

printf(“\n CLIENT ERROR: Cannot connect to the server \n”);

close(skfd);

exit(1);

printf(“\n CLIENT: Connected to the server. \n”);

/*send a message to the echo server*/

if(( w = write(skfd, sbuff, 128)) < 0 )

printf(“\n CLIENT ERROR: Cannot send messages to the echo server

\n ”);

close(skfd);

exit(1);

printf(“\n CLIENT: Message sent to echo server \n”);

/*read back the echoed message from server*/

if (( r = read(skfd, rbuff, 128)) < 0 )

printf(“\n CLIENT ERROR: Cannot receive message from server. \n”);

else

{
 rbuff[r] = ‘\0’;

/*print the received message on console*/

printf(“\n CLIENT: Message from echo server: %s \n”, rbuff );

close(skfd);

exit(1);

} /*main ends */

Output:

Q3. UDP_Echo

SERVER
Code:-

#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>

struct sockaddr_in serv_addr, cli_addr;

int sockfd, r, w, cli_addr_len;
unsigned short serv_port = 25020;
char serv_ip[] = "127.0.0.1";
char buff[256];

int main() {
bzero(&serv_addr, sizeof(serv_addr));
 serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(serv_port);
inet_aton(serv_ip, &serv_addr.sin_addr);

printf("\n UDP ECHO SERVER \n");

if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {

printf("\n SERVER ERROR: Cannot create socket. \n");
exit(1);
}

if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {

printf("\n SERVER ERROR: Cannot bind\n");
close(sockfd);
exit(1);
}

printf("\n SERVER: Listening for clients… Press Cntrl + C to stop echo server. \n");

for (;;) {
cli_addr_len = sizeof(cli_addr);
r = recvfrom(sockfd, buff, 256, 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
if (r < 0) {
printf("\n SERVER ERROR: Cannot receive message from client. \n");
continue;
}

buff[r] = '\0';
printf("\n SERVER: Received message '%s' from %s\n", buff, inet_ntoa(cli_addr.sin_addr));

w = sendto(sockfd, buff, r, 0, (struct sockaddr*)&cli_addr, cli_addr_len);

if (w < 0)
printf("\n SERVER ERROR: Cannot send message to the client \n");
else
printf("\n SERVER: Echoed back '%s' to %s \n", buff, inet_ntoa(cli_addr.sin_addr));
}

close(sockfd);
return 0;
}

CLIENT
Code:-

#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>

struct sockaddr_in serv_addr;

int skfd, r, w, serv_addr_len;
unsigned short serv_port = 25020;
char serv_ip[] = "127.0.0.1";
char rbuff[256];
char sbuff[256];

int main() {
bzero(&serv_addr, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(serv_port);
inet_aton(serv_ip, &serv_addr.sin_addr);

printf("\n UDP ECHO CLIENT \n");

printf("\n Enter Message \n");
scanf("%[^\n]s", sbuff);

if ((skfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {

printf("\n CLIENT ERROR: Cannot create socket. \n");
exit(1);
}

serv_addr_len = sizeof(serv_addr);

w = sendto(skfd, sbuff, strlen(sbuff), 0, (struct sockaddr*)&serv_addr, serv_addr_len);

if (w < 0) {
printf("\n CLIENT ERROR: Cannot send message to the echo server \n");
close(skfd);
exit(1);
}
printf("\n CLIENT: Message sent to echo server \n");

r = recvfrom(skfd, rbuff, 256, 0, (struct sockaddr*)&serv_addr, &serv_addr_len);

if (r < 0) {
printf("\n CLIENT ERROR: Cannot receive message from server. \n");
} else {
rbuff[r] = '\0';
printf("\n CLIENT: Message from echo server: %s \n", rbuff);
}

close(skfd);
return 0;
}
Output:

Q4. TCP_Time

SERVER
Code:-

#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<time.h>

time_t ticks;

int main()
{
struct sockaddr_in serv_addr, cli_addr;
int skfd, cli_fd, r, cli_len;
int short serv_port = 25020;
char serv_ip[] = "127.0.0.1";
char buff[128];

bzero(&serv_addr, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(serv_port);
inet_aton(serv_ip, (&serv_addr.sin_addr));

printf("\n TCP TIME SERVER.\n");

// creating TCP socket

if ((skfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
 {
printf("\n SERVER ERROR: Cannot create socket.\n");
exit(1);
}

if ((bind(skfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))) < 0)

{
printf("\n SERVER ERROR: Cannot bind.\n");
close(skfd);
exit(1);
}

if ((listen(skfd, 5)) < 0)

{
printf("\n SERVER ERROR: Cannot listen.\n");
close(skfd);
exit(1);
}

printf("\n SERVER: Waiting for client...Press Ctrl + C to stop server.\n");

while (1)
{
cli_len = sizeof(cli_addr);

if ((cli_fd = accept(skfd, (struct sockaddr*)&cli_addr, (socklen_t*)&cli_len)) < 0)

{
printf("\n SERVER ERROR: Cannot accept.\n");
close(skfd);
exit(1);
}

ticks = time(NULL);
snprintf(buff, sizeof(buff), "%s", ctime(&ticks));

write(cli_fd, buff, strlen(buff));

printf("\n SERVER: Time sent to client %s:%d - %s",

inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port), buff);

close(cli_fd);
}

close(skfd);
return 0;
}
CLIENT
Code:-

#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

int main()
{
struct sockaddr_in serv_addr;
int skfd, r;
int short serv_port = 25020;
char serv_ip[] = "127.0.0.1";
char buff[128];

bzero(&serv_addr, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(serv_port);
inet_aton(serv_ip, (&serv_addr.sin_addr));

printf("\n TCP TIME CLIENT.\n");

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

{
printf("\n CLIENT ERROR: Cannot create socket.\n");
exit(1);
}

if ((connect(skfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr))) < 0)

{
printf("\n CLIENT ERROR: Cannot connect to server.\n");
close(skfd);
exit(1);
}

r = read(skfd, buff, sizeof(buff) - 1);

 if (r < 0)
{
printf("\n CLIENT ERROR: Cannot receive.\n");
close(skfd);
exit(1);
}

buff[r] = '\0';
printf("\n CLIENT: Time received from server: %s\n", buff);

close(skfd);
return 0;
}

Output: