Computer Networks

Socket Programming

Question # 1

Client Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define SERVER_IP "127.0.0.1" // Server IP address

#define SERVER_PORT 12345 #define
BUFFER_SIZE 1024

int main() {
int sockfd;
struct sockaddr_in server_addr;
char buffer[BUFFER_SIZE];

// Create a UDP socket

sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) { perror("Error in
socket creation");
exit(1);
}

// Configure server address

memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
server_addr.sin_port = htons(SERVER_PORT);

while (1) {
 // Get a message from the client's console and send it to the server
printf("Client: ");
fgets(buffer, BUFFER_SIZE, stdin);
if (buffer[0] == 'q') {
break;
}

// Send the message to the server

sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));

// Receive data from the server

ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0, NULL, NULL);
if (recv_len < 0) {
perror("Error in recvfrom");
exit(1);
}

// Null-terminate the received data

buffer[recv_len] = '\0';

// Display the message received from the server

printf("Server: %s\n", buffer);
}

close(sockfd);
return 0; }

Server Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define SERVER_PORT 12345 #define

BUFFER_SIZE 1024

int main() {
int sockfd;
 struct sockaddr_in server_addr, client_addr;
socklen_t client_len = sizeof(client_addr);
char buffer[BUFFER_SIZE];

// Create a UDP socket

sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) { perror("Error in socket
creation"); exit(1);
}

// Configure server address

memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(SERVER_PORT);

// Bind the socket to the server address

if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("Error in binding");
exit(1);
}

printf("UDP chat server is running on port %d...\n", SERVER_PORT);

while (1) {
// Receive data from a client ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
(struct sockaddr *)&client_addr,
&client_len); if (recv_len < 0) {
perror("Error in recvfrom");
exit(1);
}

// Null-terminate the received data

buffer[recv_len] = '\0';

// Display the message received from the client

printf("Client %s:%d: %s\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port),
buffer);

// Get a message from the server's console and send it to the client
printf("Server: ");
fgets(buffer, BUFFER_SIZE, stdin);
 if (buffer[0] == 'q') {
break;
}

// Send the message to the client

sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&client_addr, client_len);
}

close(sockfd);
return 0;
}
Output:
 Question # 2
Client Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define SERVER_IP "127.0.0.1" // Server IP address

#define SERVER_PORT 12345
#define BUFFER_SIZE 1024

int main() {
int sockfd; struct sockaddr_in
server_addr;
char buffer[BUFFER_SIZE];

// Create a TCP socket sockfd =

socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("Error in socket creation");
exit(1);
}

// Configure server address

memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
server_addr.sin_port = htons(SERVER_PORT);

// Connect to the server

if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("Error in connecting to server"); exit(1);
}
 while (1) {
// Get a message from the client's console and send it to the server
printf("Client: Enter a message to send to the server (or 'q' to quit): ");
fgets(buffer, BUFFER_SIZE, stdin);

if (buffer[0] == 'q') {
break;
}

// Send the message to the server

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

// Receive data from the server

ssize_t recv_len = recv(sockfd, buffer, BUFFER_SIZE, 0);
if (recv_len < 0) { perror("Error in recv");
exit(1);
} else if (recv_len == 0) {
printf("Server disconnected.\n");
break;
}

// Null-terminate the received data

buffer[recv_len] = '\0';

// Display the message received from the server

printf("Server: %s\n", buffer);
}

close(sockfd);
return 0;
}

Server Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define SERVER_PORT 12345

#define BUFFER_SIZE 1024

int main() { int sockfd,

client_sockfd;
struct sockaddr_in server_addr, client_addr;
socklen_t client_len = sizeof(client_addr);
char buffer[BUFFER_SIZE];

// Create a TCP socket

sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("Error in socket creation");
exit(1);
}

// Configure server address

memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(SERVER_PORT);

// Bind the socket to the server address

if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("Error in binding"); exit(1);
}

// Listen for incoming connections

if (listen(sockfd, 5) < 0) {
perror("Error in listening");
exit(1);
}

printf("TCP chat server is running on port %d...\n", SERVER_PORT);

// Accept a client connection

client_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_len); if (client_sockfd < 0) {
perror("Error in accepting connection");
exit(1);
}

while (1) {
 // Receive data from the client
ssize_t recv_len = recv(client_sockfd, buffer, BUFFER_SIZE, 0);
if (recv_len < 0) { perror("Error in recv"); exit(1);
} else if (recv_len == 0) {
printf("Client disconnected.\n");
break;
}

// Null-terminate the received data

buffer[recv_len] = '\0';

// Display the message received from the client

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

// Get a message from the server's console and send it to the client
printf("Server: Enter a message to send to the client (or 'q' to quit): ");
fgets(buffer, BUFFER_SIZE, stdin);

if (buffer[0] == 'q') {
break;
}

// Send the message to the client

send(client_sockfd, buffer, strlen(buffer), 0);
}

close(client_sockfd);
close(sockfd);
return 0;
}
Output:
Analysis and Evaluation: UDP:
• Connectionless, low overhead.
• No guaranteed delivery, lower latency.
• Suitable for real-time applications.
• No reliability guarantees, needs custom error handling.
TCP:
• Connection-oriented, higher overhead.
• Guaranteed delivery, ordered data.
• Suitable for reliable data transfer.
• Built-in error handling and correction.
Choose UDP for low-latency real-time applications, and TCP for reliable, ordered data transfer.

Question # 3
Client Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define SERVER_IP "127.0.0.1"

#define SERVER_PORT 5354
#define BUFFER_SIZE 1024

int main() {
int sockfd;
struct
sockaddr_in
server_addr;
socklen_t server_len = sizeof(server_addr);
char buffer[BUFFER_SIZE];
const char *ip_address;

// Create a UDP socket for the DNS client

sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
 perror("Error in socket creation");
exit(1);
}

// Configure server address

memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
server_addr.sin_port = htons(SERVER_PORT);

// Query the DNS server for a hostname

printf("Enter a hostname to query the DNS server: ");
fgets(buffer, BUFFER_SIZE, stdin);

// Remove the newline character from the input

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

// Send the DNS query (hostname) to the server

sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&server_addr, server_len);

// Receive and display the IP address from the server

ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0, NULL, NULL);
if (recv_len < 0) { perror("Error in recvfrom"); exit(1);
}

buffer[recv_len] = '\0';
printf("Resolved IP address: %s\n", buffer);

close(sockfd);
return 0;
}

Server Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define SERVER_IP "127.0.0.1"
#define SERVER_PORT 5354
#define BUFFER_SIZE 1024

// Structure to hold DNS mappings

struct DNSMapping { const char
*hostname;
const char *ip_address;
};

// DNS mappings for common social media sites struct

DNSMapping dns_mappings[] = {
{"www.facebook.com", "192.168.1.10"},
{"www.twitter.com", "192.168.1.20"},
{"www.instagram.com", "192.168.1.30"},
{"www.linkedin.com", "192.168.1.40"},
{"www.youtube.com", "192.168.1.50"},
{"www.reddit.com", "192.168.1.60"},
{"www.pinterest.com", "192.168.1.70"},
{"www.tumblr.com", "192.168.1.80"},
{"www.snapchat.com", "192.168.1.90"},
{"www.whatsapp.com", "192.168.1.100"},
{NULL, NULL} // End of the mapping list
};

// Function to resolve a hostname to an IP address const char

*resolve_hostname(const char *hostname) { for (int i = 0;
dns_mappings[i].hostname != NULL; i++) { if
(strcmp(hostname, dns_mappings[i].hostname) == 0) {
return dns_mappings[i].ip_address;
}
}
return "Unknown";
}

int main() {
int sockfd;
struct sockaddr_in server_addr, client_addr;
socklen_t client_len = sizeof(client_addr);
char buffer[BUFFER_SIZE];
 const char *ip_address;

// Create a UDP socket for the DNS server

sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("Error in socket creation");
exit(1);
}

// Configure server address

memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
server_addr.sin_port = htons(SERVER_PORT);

// Bind the socket to the server address

if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("Error in binding"); exit(1);
}

printf("DNS server is running on IP %s and port %d...\n", SERVER_IP, SERVER_PORT);

while (1) {
// Receive DNS query from the client
ssize_t recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE, 0, (struct sockaddr *)&client_addr,
&client_len);
if (recv_len < 0) {
perror("Error in recvfrom");
exit(1);
}

// Null-terminate the received data

buffer[recv_len] = '\0';

// Resolve the received hostname to an IP address

ip_address = resolve_hostname(buffer);

// Send the IP address back to the client

sendto(sockfd, ip_address, strlen(ip_address), 0, (struct sockaddr *)&client_addr, client_len);
 printf("Resolved %s to %s\n", buffer, ip_address);
}

close(sockfd);
return 0;
}

Output: