NAME: RADHIKA GANDHI

COURSE: BSC COMPUTER SCIENCE

SUBJECT: UNIX NETWORK PROGRAMMING PRACTICAL
ROLL NO: 2K22/CS/59
SEMESTER: V
EXAMINATION ROLL NO: 22013570039

Q1. Implement TCP Echo client and TCP Echo server (Iterative).

Echo server:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 8080

#define BUFFER_SIZE 1024

int main() {

int server_fd, new_socket;

struct sockaddr_in address;

int opt = 1;

int addrlen = sizeof(address);

char buffer[BUFFER_SIZE] = {0};

// Creating socket file descriptor

if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {

perror("socket failed");

exit(EXIT_FAILURE);

}
// Attaching socket to the port

if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &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);

// Binding the socket

if (bind(server_fd, (struct sockaddr *)&address, sizeof(address))

< 0) {

perror("bind failed");

exit(EXIT_FAILURE);

// Putting the server in listening mode

if (listen(server_fd, 3) < 0) {

perror("listen");

exit(EXIT_FAILURE);

// Accepting a client connection

while (1) {

new_socket = accept(server_fd, (struct sockaddr *)&address,

(socklen_t*)&addrlen);

if (new_socket < 0) {

perror("accept");

exit(EXIT_FAILURE);

// Echoing back the received message

int valread = read(new_socket, buffer, BUFFER_SIZE);

send(new_socket, buffer, valread, 0);

close(new_socket);

return 0;

Echo client:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 8080

#define BUFFER_SIZE 1024

int main() {

int sock = 0;

struct sockaddr_in serv_addr;

char buffer[BUFFER_SIZE] = {0};

// Creating socket

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

printf("\n Socket creation error \n");

return-1;

memset(&serv_addr, 0, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;

serv_addr.sin_port = htons(PORT);

// Convert IPv4 and IPv6 addresses from text to binary format

if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0)

printf("\nInvalid address/ Address not supported \n");

return-1;

// Connect to the server

if (connect(sock, (struct sockaddr *)&serv_addr,

sizeof(serv_addr)) < 0) {

printf("\nConnection Failed \n");

return-1;

// Send a message

const char *message = "Hello, Echo Server!";

send(sock, message, strlen(message), 0);

// Read the echoed message

int valread = read(sock, buffer, BUFFER_SIZE);

printf("Echoed message: %s\n", buffer);

// Close the socket

close(sock);

return 0;

Q2. Implement TCP Echo client and TCP Echo server (Concurrent)

Echo client:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 8080

#define BUFFER_SIZE 1024

int main() {
int sock = 0;

struct sockaddr_in serv_addr;

char buffer[BUFFER_SIZE] = {0};

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

perror("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("\nInvalid address/ Address not supported \n");

return-1;

if (connect(sock, (struct sockaddr *)&serv_addr,

sizeof(serv_addr)) < 0) {

printf("\nConnection Failed \n");

return-1;

while (1) {

printf("Enter message: ");

fgets(buffer, BUFFER_SIZE, stdin);

// Remove trailing newline character

buffer[strcspn(buffer, "\n")] = '\0';

send(sock, buffer, strlen(buffer), 0);

if (strcmp(buffer, "exit") == 0) {

break;

int valread = recv(sock, buffer, BUFFER_SIZE, 0);

buffer[valread] = '\0'; // Null-terminate the received string

printf("Echo from server: %s\n", buffer);

}

close(sock);

return 0;

Echo Server (concurrent):

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <pthread.h>

#define PORT 8080

#define BUFFER_SIZE 1024

void *handle_client(void *client_socket) {

int sock = *(int*)client_socket;

char buffer[BUFFER_SIZE];

int n;

while ((n = recv(sock, buffer, sizeof(buffer), 0)) > 0) {

send(sock, buffer, n, 0);

close(sock);

free(client_socket);

return NULL;

int main() {

int server_fd, *new_socket;

struct sockaddr_in address;

int opt = 1;

int addrlen = sizeof(address);

if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {

perror("socket failed");

exit(EXIT_FAILURE);

if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &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 failed");

exit(EXIT_FAILURE);

printf("Server listening on port %d\n", PORT);

while (1) {

new_socket = malloc(sizeof(int));

if ((*new_socket = accept(server_fd, (struct sockaddr

*)&address, (socklen_t*)&addrlen)) < 0) {

perror("accept failed");

free(new_socket);

continue;

pthread_t thread_id;
pthread_create(&thread_id, NULL, handle_client, new_socket);

pthread_detach(thread_id);

return 0;

Q3. Implement TCP daytime client and TCP daytime server (Iterative).

Tcp daytime client(Iterative):

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 12345

#define BUFFER_SIZE 1024

int main() {

int sock = 0;

struct sockaddr_in serv_addr;

char buffer[BUFFER_SIZE] = {0};

// Create socket

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

perror("Socket creation error");

return-1;
}

memset(&serv_addr, 0, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;

serv_addr.sin_port = htons(PORT);

// Convert IPv4 and IPv6 addresses from text to binary format

if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {

printf("\nInvalid address/ Address not supported \n");

return-1;

// Connect to the server

if (connect(sock, (struct sockaddr *)&serv_addr,

sizeof(serv_addr)) < 0) {

printf("\nConnection Failed \n");

return-1;

// Read the message from server

read(sock, buffer, BUFFER_SIZE);

printf("%s", buffer);

// Close the socket

close(sock);

return 0;

Tcp DaytimeServer(Iterative):
Q4.Implement TCP daytime client and TCP daytime server (concurrent).

Tcp daytime Client(Concurrent):

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdio.h>

#define MAXLINE 4096

int main(int argc, char **argv) {

int sockfd;

struct sockaddr_in servaddr;

char recvline[MAXLINE];

if (argc != 2) {

fprintf(stderr, "Usage: %s <Server IP>\n", argv[0]);

exit(1);

sockfd = socket(AF_INET, SOCK_STREAM, 0);

if (sockfd < 0) {

perror("Socket creation error");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(8080);

if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {

perror("inet_pton error");

exit(1);

if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {

 perror("Connect error");

exit(1);

int n;

while ((n = read(sockfd, recvline, MAXLINE - 1)) > 0) {

recvline[n] = '\0';

fputs(recvline, stdout);

if (n < 0) {

perror("Read error");

close(sockfd);

return 0;

Server code:

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdio.h>

#include <time.h>

#include <signal.h>

#define MAXLINE 4096

#define LISTENQ 8080

void handle_client(int connfd) {

char buff[MAXLINE];

time_t ticks;

ticks = time(NULL);

snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));

write(connfd, buff, strlen(buff));

close(connfd);

exit(0);

int main() {

int listenfd, connfd;

struct sockaddr_in servaddr;

signal(SIGCHLD, SIG_IGN);

listenfd = socket(AF_INET, SOCK_STREAM, 0);

if (listenfd < 0) {

perror("Socket creation error");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(8080);

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

perror("Bind error");

exit(1);

if (listen(listenfd, LISTENQ) < 0) {

perror("Listen error");

exit(1);

printf("Concurrent Daytime server is running on port 8080...\n");

for ( ; ; ) {

connfd = accept(listenfd, (struct sockaddr *)NULL, NULL);

if (connfd < 0) {

perror("Accept error");

continue;
 }

if (fork() == 0) {

close(listenfd);

handle_client(connfd);

close(connfd);

return 0;

5.Implement UDP echo client and UDP echo server.

Client code:

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdio.h>

#define MAXLINE 4096

int main(int argc, char **argv) {

int sockfd;

struct sockaddr_in servaddr;

char message[MAXLINE], buffer[MAXLINE];

 if (argc != 2) {

fprintf(stderr, "Usage: %s <Server IP>\n", argv[0]);

exit(1);

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

if (sockfd < 0) {

perror("Socket creation error");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(12345);

if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {

perror("inet_pton error");

exit(1);

printf("Enter a message to send to the server: ");

fgets(message, MAXLINE, stdin);

message[strcspn(message, "\n")] = '\0';

if (sendto(sockfd, message, strlen(message), 0, (struct sockaddr *)&servaddr,

sizeof(servaddr)) < 0) {

perror("Send error");

exit(1);

socklen_t len = sizeof(servaddr);

int n = recvfrom(sockfd, buffer, MAXLINE, 0, (struct sockaddr *)&servaddr, &len);

if (n < 0) {

perror("Receive error");

exit(1);

buffer[n] = '\0';
printf("Received from server: %s\n", buffer);

close(sockfd);

return 0;

Server code:

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdio.h>

#define MAXLINE 4096

int main() {

int sockfd;

struct sockaddr_in servaddr, cliaddr;

char buffer[MAXLINE];

socklen_t len;

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

if (sockfd < 0) {

perror("Socket creation error");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(12345);

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

perror("Bind error");

exit(1);

}
 printf("UDP Echo Server running on port 12345...\n");

while (1) {

len = sizeof(cliaddr);

int n = recvfrom(sockfd, buffer, MAXLINE, 0, (struct sockaddr *)&cliaddr, &len);

if (n < 0) {

perror("Receive error");

exit(1);

buffer[n] = '\0';

printf("Received message: %s\n", buffer);

if (sendto(sockfd, buffer, n, 0, (struct sockaddr *)&cliaddr, len) < 0) {

perror("Send error");

exit(1);

close(sockfd);

return 0;

6.Implement UDP daytime client and UDP daytime server.

Client code:

#include <sys/socket.h>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdio.h>

#define MAXLINE 4096

int main(int argc, char **argv) {

int sockfd;

struct sockaddr_in servaddr;

char buffer[MAXLINE];

if (argc != 2) {

fprintf(stderr, "Usage: %s <Server IP>\n", argv[0]);

exit(1);

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

if (sockfd < 0) {

perror("Socket creation error");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(12345);

if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {

perror("inet_pton error");

exit(1);

char *message = "Daytime request";

if (sendto(sockfd, message, strlen(message), 0, (struct sockaddr *)&servaddr,

sizeof(servaddr)) < 0) {

perror("Send error");

exit(1);
 }

socklen_t len = sizeof(servaddr);

int n = recvfrom(sockfd, buffer, MAXLINE, 0, (struct sockaddr *)&servaddr, &len);

if (n < 0) {

perror("Receive error");

exit(1);

buffer[n] = '\0';

printf("Received from server: %s\n", buffer);

close(sockfd);

return 0;

server code:

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdio.h>

#include <time.h>

#define MAXLINE 4096

int main() {

int sockfd;

struct sockaddr_in servaddr, cliaddr;

char buffer[MAXLINE];

socklen_t len;

time_t ticks;

sockfd = socket(AF_INET, SOCK_DGRAM, 0);

if (sockfd < 0) {

perror("Socket creation error");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(12345);

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

perror("Bind error");

exit(1);

printf("UDP Daytime Server running on port 12345...\n");

while (1) {

len = sizeof(cliaddr);

int n = recvfrom(sockfd, buffer, MAXLINE, 0, (struct sockaddr *)&cliaddr, &len);

if (n < 0) {

perror("Receive error");

exit(1);

ticks = time(NULL);

snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&ticks));

if (sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&cliaddr, len) < 0) {

perror("Send error");

exit(1);

close(sockfd);

return 0;

}
7.Implement TCP client and server (concurrent) where client gets input from the user and sends it to
server. Server displays it on the screen. Server then gets another input from the user and sends it to
client. Client displays it on the screen. The process continues till server or client sends “bye” to the
other party.

Client code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 12345

#define MAXLINE 1024

int main(int argc, char *argv[]) {

int sockfd;

struct sockaddr_in servaddr;

char buffer[MAXLINE];

int n;

if (argc != 2) {

fprintf(stderr, "Usage: %s <server_ip>\n", argv[0]);

exit(1);

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

 perror("Socket creation failed");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(PORT);

if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {

perror("Invalid address or address not supported");

exit(1);

if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {

perror("Connection failed");

exit(1);

printf("Connected to server at %s on port %d\n", argv[1], PORT);

while (1) {

printf("Client: ");

bzero(buffer, sizeof(buffer));

fgets(buffer, sizeof(buffer), stdin);

write(sockfd, buffer, strlen(buffer));

if (strncmp(buffer, "bye", 3) == 0) {

printf("Client sent 'bye'. Closing connection...\n");

break;

bzero(buffer, sizeof(buffer));

n = read(sockfd, buffer, sizeof(buffer));

if (n <= 0) {

break;

printf("Server: %s", buffer);

 if (strncmp(buffer, "bye", 3) == 0) {

printf("Server sent 'bye'. Closing connection...\n");

break;

close(sockfd);

return 0;

Server code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <pthread.h>

#include <arpa/inet.h>

#define PORT 12345

#define MAXLINE 1024

void *client_handler(void *arg);

int main() {

int listenfd, connfd;

struct sockaddr_in servaddr, cliaddr;

socklen_t clilen;

pthread_t tid;

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

perror("Socket creation failed");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(PORT);
 if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {

perror("Bind failed");

exit(1);

if (listen(listenfd, 10) < 0) {

perror("Listen failed");

exit(1);

printf("Server listening on port %d...\n", PORT);

while (1) {

clilen = sizeof(cliaddr);

if ((connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen)) < 0) {

perror("Accept failed");

continue;

if (pthread_create(&tid, NULL, client_handler, (void *)&connfd) != 0) {

perror("Thread creation failed");

exit(1);

pthread_detach(tid);

return 0;

void *client_handler(void *arg) {

int connfd = *(int *)arg;

char buffer[MAXLINE];

int n;

while (1) {

bzero(buffer, sizeof(buffer));

n = read(connfd, buffer, sizeof(buffer));

if (n <= 0) {
 break;

printf("Server received: %s", buffer);

if (strncmp(buffer, "bye", 3) == 0) {

printf("Client sent 'bye'. Closing connection...\n");

break;

printf("Server: ");

bzero(buffer, sizeof(buffer));

fgets(buffer, sizeof(buffer), stdin);

write(connfd, buffer, strlen(buffer));

if (strncmp(buffer, "bye", 3) == 0) {

printf("Server sent 'bye'. Closing connection...\n");

break;

close(connfd);

return NULL;

}
8.Implement TCP client and server(concurrent) where client requests server to transfer a file.
Assume file is smaller than 1K size. If the file is present on the server, it is sent to the client otherwise
an error message is sent to client. Client copies the file on the hard disk and disconnects.

Client code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 8080

#define BUFFER_SIZE 1024

int main() {

int sock;

struct sockaddr_in server_addr;

char file_name[BUFFER_SIZE];

char buffer[BUFFER_SIZE];

FILE *file;

if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

perror("Socket creation failed");

exit(1);

server_addr.sin_family = AF_INET;

server_addr.sin_port = htons(PORT);

server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

if (connect(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {

perror("Connection failed");

exit(1);
 }

printf("Enter the file name to request: ");

scanf("%s", file_name);

send(sock, file_name, sizeof(file_name), 0);

recv(sock, buffer, sizeof(buffer), 0);

if (strcmp(buffer, "ERROR: File not found") == 0) {

printf("Error: File not found on the server\n");

else if (strcmp(buffer, "FOUND") == 0) {

file = fopen(file_name, "wb");

if (file == NULL) {

perror("Failed to create file");

close(sock);

exit(1);

ssize_t n;

while ((n = recv(sock, buffer, sizeof(buffer), 0)) > 0) {

fwrite(buffer, 1, n, file);

printf("File '%s' received and saved successfully.\n", file_name);

fclose(file);

close(sock);

return 0;

Server code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>
#include <pthread.h>

#define PORT 8080

#define MAX_CLIENTS 10

#define BUFFER_SIZE 1024

void *handle_client(void *client_socket) {

int sock = *(int *)client_socket;

char file_name[BUFFER_SIZE];

char buffer[BUFFER_SIZE];

recv(sock, file_name, sizeof(file_name), 0);

printf("Client requested file: %s\n", file_name);

FILE *file = fopen(file_name, "rb");

if (file == NULL) {

strcpy(buffer, "ERROR: File not found");

send(sock, buffer, sizeof(buffer), 0);

} else {

strcpy(buffer, "FOUND");

send(sock, buffer, sizeof(buffer), 0);

size_t n;

while ((n = fread(buffer, 1, sizeof(buffer), file)) > 0) {

send(sock, buffer, n, 0);

fclose(file);

printf("File '%s' sent successfully.\n", file_name);

close(sock);

free(client_socket);

pthread_exit(NULL);

int main() {

int server_fd, *new_sock;

struct sockaddr_in server_addr, client_addr;

socklen_t addr_len = sizeof(client_addr);

pthread_t thread_id;

if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

perror("Socket creation failed");

exit(1);

server_addr.sin_family = AF_INET;

server_addr.sin_addr.s_addr = INADDR_ANY;

server_addr.sin_port = htons(PORT);

if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {

perror("Bind failed");

exit(1);

if (listen(server_fd, MAX_CLIENTS) < 0) {

perror("Listen failed");

exit(1);

printf("Server is running on port %d...\n", PORT);

while (1) {

new_sock = malloc(sizeof(int));

*new_sock = accept(server_fd, (struct sockaddr *)&client_addr, &addr_len);

if (*new_sock < 0) {

perror("Accept failed");

free(new_sock);

continue;

printf("Connection accepted\n");

if (pthread_create(&thread_id, NULL, handle_client, (void *)new_sock) != 0) {

perror("Thread creation failed");

close(*new_sock);

free(new_sock);
 }

return 0;

9.Implement UDP client and UDP server where server displays the IP address and port number of the
client sending the datagram. Client sends a datagram (size 64 bytes) three times to the same server.
server sends the message back to client. Client reports the time elapsed in sending and receiving of
the message. Use connected UDP sockets.

Client code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#include <time.h>

#define PORT 12345

#define MAXLINE 64

int main(int argc, char *argv[]) {

int sockfd;

struct sockaddr_in servaddr;

char buffer[MAXLINE];
struct timespec start, end;

if (argc != 2) {

fprintf(stderr, "Usage: %s <server_ip>\n", argv[0]);

exit(1);

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

perror("Socket creation failed");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(PORT);

if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {

perror("Invalid address or address not supported");

exit(1);

if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {

perror("Connect failed");

exit(1);

printf("Connected to server at %s on port %d\n", argv[1], PORT);

for (int i = 0; i < 3; i++) {

snprintf(buffer, MAXLINE, "Message %d from client", i + 1);

clock_gettime(CLOCK_MONOTONIC, &start);

send(sockfd, buffer, strlen(buffer), 0);

int n = recv(sockfd, buffer, MAXLINE, 0);

buffer[n] = '\0';

clock_gettime(CLOCK_MONOTONIC, &end);

double elapsed_time = (end.tv_sec - start.tv_sec) + (end.tv_nsec - start.tv_nsec) / 1e9;

printf("Client received: %s\n", buffer);

printf("Time elapsed: %.6f seconds\n", elapsed_time);

 }

close(sockfd);

return 0;

Server code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 12345

#define MAXLINE 64

int main() {

int sockfd;

struct sockaddr_in servaddr, cliaddr;

socklen_t len = sizeof(cliaddr);

char buffer[MAXLINE];

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

perror("Socket creation failed");

exit(1);

memset(&servaddr, 0, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(PORT);

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

perror("Bind failed");

exit(1);

printf("Server listening on port %d...\n", PORT);

while (1) {
 int n = recvfrom(sockfd, (char *)buffer, MAXLINE, 0, (struct sockaddr *)&cliaddr, &len);

buffer[n] = '\0';

char client_ip[INET_ADDRSTRLEN];

inet_ntop(AF_INET, &cliaddr.sin_addr, client_ip, sizeof(client_ip));

printf("Received message from client: %s\n", buffer);

printf("Client IP: %s, Port: %d\n", client_ip, ntohs(cliaddr.sin_port));

sendto(sockfd, (const char *)buffer, strlen(buffer), 0, (const struct sockaddr *)&cliaddr,

len);

close(sockfd);

return 0;

10.write a program to a) display name of the host b) all IP address of the host. c) Check whether FTP
and HTTP services are running on the system. d) Display the name of the service running on port
number specified by user.

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

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

#define MAX_HOSTNAME_LEN 256

#define MAX_IPS 10

void display_host_name() {

char hostname[MAX_HOSTNAME_LEN];

if (gethostname(hostname, sizeof(hostname)) == 0) {

printf("Host Name: %s\n", hostname);

} else {

perror("Error getting hostname");

void display_ip_addresses() {

struct hostent *host_info;

struct in_addr *address;

char **ip_addresses;

char hostname[MAX_HOSTNAME_LEN];

int i = 0;

if (gethostname(hostname, sizeof(hostname)) == 0) {

host_info = gethostbyname(hostname);

if (host_info == NULL) {

perror("Error getting host information");

return;

ip_addresses = host_info->h_addr_list;
 printf("IP Addresses:\n");

while (*ip_addresses != NULL && i < MAX_IPS) {

address = (struct in_addr *)*ip_addresses;

printf("IP Address %d: %s\n", i + 1, inet_ntoa(*address));

ip_addresses++;

i++;

} else {

perror("Error getting hostname");

void check_services_running() {

struct servent *service;

service = getservbyport(htons(21), NULL);

if (service != NULL) {

printf("FTP service is running on port 21. Service name: %s\n", service->s_name);

} else {

printf("FTP service is not running on port 21.\n");

service = getservbyport(htons(80), NULL);

if (service != NULL) {

printf("HTTP service is running on port 80. Service name: %s\n", service->s_name);

} else {

printf("HTTP service is not running on port 80.\n");

void display_service_by_port(int port) {

struct servent *service;

service = getservbyport(htons(port), NULL);

if (service != NULL) {

printf("Service running on port %d: %s\n", port, service->s_name);

 } else {

printf("No service running on port %d.\n", port);

int main() {

int port;

display_host_name();

display_ip_addresses();

check_services_running();

printf("Enter port number to check for the service: ");

scanf("%d", &port);

display_service_by_port(port);

return 0;