Name: Anshul

SID : 20105131

Branch : Electronics & Communication Engineering

Computer Networks Assignment -3

Ques1: Write and explain the basic commands to edit, compile and execute ‘C’ programs in
Linux Environment?

Ans 1:

To Edit: Use a text editor to create or edit your C program. For example, using Vim: This will
open the Vim editor with a new or existing file named anshul.c. Command: vim anshul.c

To Compile: The GNU Compiler Collection (GCC) is a commonly used compiler for C programs
on Linux.

In the terminal, we use the following command to compile your C program: Command: gcc -o
output_file anshul.c

To Execute: Once the compilation is successful, we can run the compiled program using the
following command:

Command: . /output_file

The program will now execute, and we'll see the output in the terminal.

Ques 2: Write basic code with brief explanation of the basics of sockets programming using ‘C’

Programming Language in Linux based environment for follwing

 I. Creating and destroying sockets – socket() and close() functions
II. Specifying addresses – sockaddr and sockaddr_in structures
III. Understanding the syntax, purpose and use of various functions used in sockets
programming in ‘C’ programming language –

i. connect(),

ii. send()

iii. recv()

iv. bind()

v. listen()

vi. accept(),

vii. sendto(),

viii. recvfrom()

Ans 2:

Code:

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

int main() {
 int server_socket = socket(AF_INET, SOCK_STREAM, 0); if
(server_socket == -1) { perror("Error creating socket");
exit(EXIT_FAILURE);
}

printf("Socket created successfully\n"); if

(close(server_socket) == -1) { perror("Error
closing socket"); exit(EXIT_FAILURE);

printf("Socket closed successfully\n"); return 0;

Explanation:

• socket() is used to create a new socket.

• It takes three arguments:

o AF_INET: Address family (IPv4). o SOCK_STREAM: Type of socket (in this case,
a stream socket, which is TCP).

o 0: Protocol (0 specifies the default protocol for the given socket type).
• After creating the socket, it's important to check if the creation was successful. If not, an
error message is printed, and the program exits.

• At this point, you can perform various operations using the created socket.

• close() is used to close the socket when it is no longer needed.

• It takes the socket descriptor as an argument.

• Again, error checking is done to ensure the socket is closed properly.

• If all operations are successful, the program prints messages indicating that the socket
was created and closed successfully.
b)

Code:

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

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 8080

#define MAX_CONNECTIONS 5

int main() {

int server_fd, new_socket; struct sockaddr_in

server_addr, client_addr; socklen_t addr_len =
sizeof(client_addr);

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

perror("Socket creation failed"); exit(EXIT_FAILURE);

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(PORT);

if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) { perror("Bind

failed");

exit(EXIT_FAILURE);
}
 if (listen(server_fd, MAX_CONNECTIONS) == -1) {

perror("Listen failed");

exit(EXIT_FAILURE);

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

if ((new_socket = accept(server_fd, (struct sockaddr*)&client_addr, &addr_len)) == -1) {

perror("Accept failed");
exit(EXIT_FAILURE);

printf("Connection accepted from %s:%d\n", inet_ntoa(client_addr.sin_addr),

ntohs(client_addr.sin_port));

close(new_socket);

close(server_fd);

return 0;
}

Explanation:

• socket(AF_INET, SOCK_STREAM, 0): Creates a new socket using IPv4 and TCP.
• bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)): Associates the
socket with the specified address and port.

• listen(server_fd, MAX_CONNECTIONS): Listens for incoming connections with a

maximum queue size.
 • accept(server_fd, (struct sockaddr*)&client_addr, &addr_len): Accepts an incoming
connection and returns a new socket for data exchange.

• The struct sockaddr_in structure is used to represent the server and client addresses.

c)

Code:

Server.c(server side)

#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 server_addr, client_addr; int opt =

1;

int addrlen = sizeof(server_addr); char

buffer[BUFFER_SIZE] = {0};

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

perror("Socket creation failed"); exit(EXIT_FAILURE);

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

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

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(EXIT_FAILURE);

if (listen(server_fd, 3) < 0) { perror("Listen

failed"); exit(EXIT_FAILURE);
 }

if ((new_socket = accept(server_fd, (struct sockaddr *)&client_addr,

(socklen_t*)&addrlen)) < 0) { perror("Accept
failed"); exit(EXIT_FAILURE);

if (recv(new_socket, buffer, BUFFER_SIZE, 0) < 0) {

perror("Receive failed"); exit(EXIT_FAILURE);

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

char *response = "Hello from server!"; send(new_socket,

response, strlen(response), 0); printf("Response sent to client\n");

close(new_socket);
close(server_fd); return 0;

Client.c(client side)

#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 server_addr;

char buffer[BUFFER_SIZE] = {0};

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

perror("Socket creation failed"); exit(EXIT_FAILURE);

server_addr.sin_family = AF_INET; server_addr.sin_port =

htons(PORT);

if (inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr) <= 0) { perror("Invalid

address/ Address not supported"); exit(EXIT_FAILURE);

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

perror("Connection Failed"); exit(EXIT_FAILURE);

}
 char *message = "Hello from client!"; send(sock,
message, strlen(message), 0); printf("Message sent to
server\n");

if (recv(sock, buffer, BUFFER_SIZE, 0) < 0) {

perror("Receive failed"); exit(EXIT_FAILURE);

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

close(sock); return
0;

Explanation:
• connect(): This function is used to connect a socket to a server. It takes the socket file
descriptor, the server address, and the length of the server address as arguments.
• send(): This function is used to send data over the socket. It takes the socket file
descriptor, the message to be sent, the length of the message, and flags as arguments.
• recv(): This function is used to receive data from the socket. It takes the socket file
descriptor, the buffer to store the received data, the maximum length of the data to be
received, and flags as arguments.
• bind(): This function is used to bind a socket to a particular address and port. It takes the
socket file descriptor, the address to bind to, and the length of the address as
arguments.
• listen(): This function is used to put the socket in listening mode. It takes the socket file
descriptor and the maximum number of pending connections as arguments.
 • accept(): This function is used to accept a connection request from a client. It takes the
socket file descriptor, the address of the client, and the length of the address as
arguments.
• sendto(): This function is used to send data to a specific address. It takes the socket file
descriptor, the message to be sent, the length of the message, flags, the address to send
to, and the length of the address as arguments.
• recvfrom(): This function is used to receive data from a specific address. It takes the
socket file descriptor, the buffer to store the received data, the maximum length of the
data to be received, flags, the address from which to receive, and the length of the
address as arguments.

Ques3: TCP/IP based Echo Client program using ‘C’ Programming Language in Linux based
environment

Ans3:

Code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>

#define PORT 8080

#define MAX_BUFFER_SIZE 1024

int main() { int client_socket; struct
sockaddr_in server_addr; char
buffer[MAX_BUFFER_SIZE];

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

perror("Socket creation failed"); exit(EXIT_FAILURE);

server_addr.sin_family = AF_INET; server_addr.sin_port =

htons(PORT);

if (inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr) <= 0) { perror("Invalid address/

Address not supported"); exit(EXIT_FAILURE);

if (connect(client_socket, (struct sockaddr *)&server_addr, sizeof(server_addr))

== -1) {

perror("Connection failed"); exit(EXIT_FAILURE);

printf("Connected to server on port %d\n", PORT);

while (1) {

printf("Enter message to send (type 'exit' to quit): "); fgets(buffer,

MAX_BUFFER_SIZE, stdin);
 send(client_socket, buffer, strlen(buffer), 0);

if (strncmp(buffer, "exit", 4) == 0) break;

recv(client_socket, buffer, MAX_BUFFER_SIZE, 0); printf("Received from

server: %s", buffer);

close(client_socket);

return 0;

Ques4: TCP/IP based Echo server program using ‘C’ Programming Language in Linux based
environment

Ans4:

Code:
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>
#define PORT 8080

#define MAX_BUFFER_SIZE 1024

int main() {

int server_socket, client_socket; struct sockaddr_in

server_addr, client_addr; char
buffer[MAX_BUFFER_SIZE];

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

perror("Socket creation failed"); exit(EXIT_FAILURE);

server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr =

INADDR_ANY; server_addr.sin_port = htons(PORT);

if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) ==

-1) {

perror("Bind failed"); exit(EXIT_FAILURE);

}

if (listen(server_socket, 3) == -1) { perror("Listen

failed"); exit(EXIT_FAILURE);
}

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

 socklen_t addr_len = sizeof(client_addr);

if ((client_socket = accept(server_socket, (struct sockaddr *)&client_addr,

&addr_len)) == -1) { perror("Accept
failed"); exit(EXIT_FAILURE);
}

printf("Connection accepted from %s:%d\n", inet_ntoa(client_addr.sin_addr),

ntohs(client_addr.sin_port));

while (1) {

ssize_t received_bytes = recv(client_socket, buffer, MAX_BUFFER_SIZE, 0); if

(received_bytes <= 0) { printf("Client disconnected\n"); break;
}

send(client_socket, buffer, received_bytes, 0); buffer[received_bytes] = '\0';

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

close(client_socket); close(server_socket);

return 0;
}

Ques 5: UDP/IP based Echo Client Program using ‘C’ Programming Language in Linux based
environment

Ans 5:

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 8080

#define BUFFER_SIZE 1024

int main() { int clientSocket; struct

sockaddr_in serverAddr; char
buffer[BUFFER_SIZE];
 if ((clientSocket = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
perror("Error creating socket"); exit(EXIT_FAILURE);

memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET; serverAddr.sin_port =
htons(SERVER_PORT); inet_pton(AF_INET, SERVER_IP,
&serverAddr.sin_addr);

printf("Enter message to send (type 'exit' to quit):\n");

while (1) {

fgets(buffer, BUFFER_SIZE, stdin);

sendto(clientSocket, buffer, strlen(buffer), 0, (struct sockaddr*)&serverAddr,

sizeof(serverAddr));

if (strncmp(buffer, "exit", 4) == 0) break;

ssize_t recvBytes = recvfrom(clientSocket, buffer, BUFFER_SIZE, 0, NULL, NULL);

if (recvBytes == -1) {

perror("Error receiving data"); exit(EXIT_FAILURE);

}
 buffer[recvBytes] = '\0';

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

close(clientSocket);

return 0;

Ques6: UDP/IP based Echo Server Program using ‘C’ Programming Language in Linux based
environment

Ans 6:

Code:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <arpa/inet.h>
#define SERVER_PORT 8080

#define BUFFER_SIZE 1024

int main() { int

serverSocket;
struct sockaddr_in serverAddr, clientAddr; socklen_t
clientAddrLen = sizeof(clientAddr); char
buffer[BUFFER_SIZE];

if ((serverSocket = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {

perror("Error creating socket"); exit(EXIT_FAILURE);

memset(&serverAddr, 0, sizeof(serverAddr)); serverAddr.sin_family =

AF_INET; serverAddr.sin_addr.s_addr = INADDR_ANY;
serverAddr.sin_port = htons(SERVER_PORT);

if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1)

perror("Error binding socket"); exit(EXIT_FAILURE);

printf("UDP Echo Server is listening on port %d...\n", SERVER_PORT);

while (1) {
 ssize_t recvBytes = recvfrom(serverSocket, buffer, BUFFER_SIZE, 0, (struct
sockaddr*)&clientAddr, &clientAddrLen);

if (recvBytes == -1) {

perror("Error receiving data"); exit(EXIT_FAILURE);

buffer[recvBytes] = '\0';

printf("Received from %s:%d: %s", inet_ntoa(clientAddr.sin_addr),

ntohs(clientAddr.sin_port), buffer);

sendto(serverSocket, buffer, recvBytes, 0, (struct sockaddr*)&clientAddr, sizeof(clientAddr));

close(serverSocket);

return 0;