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:
