----------------------------------------------------------------------------------------------------------

Assume you are a network administrator and you have been assigned the task of setting up the IP
network.

You have a single class C IP address 200.55.1.0/24) and have to setup the following networks:

Network A= 100 Hosts

Network B = 40 Hosts

Network C = 20 hosts

Network D= 10 hosts

Network E = 6 Hosts

Network F = 2 Hosts

Write a program to effectively assign the IP addresses for the same.

----------------------------------------------------------------------------------

#include <stdio.h>

#include<stdlib.h>

#include<math.h>

#include<string.h>

#define MAX_HOSTS 254

typedef struct{

int networkSize;

char networkName;

char networkIP[16];

} Network;

int main(){

Network networks[]={

{100,'A',"200.55.1.0"},

{40,'B',""},

{20,'C',""},

{10,'D',""},

{6,'E',""},

{2,'F',""},
 };

for(int i=0;i<sizeof(networks)/sizeof(networks[0]);i++){

int subnetmask=32-(int)(log2(networks[i].networkSize));

sprintf(networks[i].networkIP,"%s/%d",networks[i].networkIP,subnetmask);

int hostCounter=1;

for(int i=0;i<sizeof(networks)/sizeof(networks[0]);i++){

printf("Network %c:\n", networks[i].networkName);

printf("Network IP: %s\n", networks[i].networkIP);

printf("Hosts:\n");

for(int j=0;j<networks[i].networkSize;j++){

printf("Hosts %d:200.55.1.%d\n",hostCounter,hostCounter);

hostCounter++;

printf("\n");

return 0;

----------------------------------------------------------------------------------

*GOBACK-N ARQ*

Assume that you are going to implement a part of GO BACK N ARQ

FLOW control algorithm. Here are the terms used in algorithm

----------------------------------------------------------------------------------

import java.util.Scanner;

public class GoBackNARQ {

Scanner scanner = new Scanner(System.in);

int n = scanner.nextInt(); // number of test cases

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

int m = scanner.nextInt();

int sf = scanner.nextInt();

int sn = scanner.nextInt();

int e1 = scanner.nextInt();

int e2 = scanner.nextInt();

int e3 = scanner.nextInt();

if (e1 == 1) { // Timeout event (E1)

sf = sn;

} else if (e2 > 0) { // Frames arrived from upper layer (E2)

sn = (sn + e2) % ((int) Math.pow(2, m));

} else if (e3 > 0) { // ACK received (E3)

sf = (sf + e3) % ((int) Math.pow(2, m));

System.out.println(sf + " " + sn);

-----------------------------------------------------------------------------------

SELECTIVE REPEAT ARQ

Assume that you need to implement SELECTIVE REPEAT ARQ

FLOW control algorithm. Here are the terms used in algorithm.

---------------------------------------------------------------------------------

import java.util.Scanner;
public class SelectiveRepeatARQ {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int testCases = scanner.nextInt();

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

int m = scanner.nextInt();

int Sf = scanner.nextInt();

int Sn = scanner.nextInt();

int E1 = scanner.nextInt();

int E2 = scanner.nextInt();

int E3 = scanner.nextInt();

// Handling events

if (E1 == 1) {

// Timeout event

Sf = Sn;

} else if (E2 > 0) {

// Frames arrived from the upper layer

Sn += E2;

} else if (E3 != 0) {

// ACK or NAK from the bottom layer

int absE3 = Math.abs(E3);

if (E3 > 0) {

// ACK received

Sf = absE3 + 1;

} else {

// NAK received

Sf = absE3;

System.out.println(Sf + " " + Sn);

}
scanner.close();

-----------------------------------------------------------------------------------

*Dns server implementation using TCP/IP protocol:Server code*

-----------------------------------------------------------------------------------

dns-server-tcp

import socket

HOST='127.0.0.1'

PORT=53

DNS_TABLE={

'google.com':'172.168.11.1',

'wikipedia.com':'192.142.18.1'

def handle_dns_server(data):

domain=data.strip().decode('utf-8')

if domain in DNS_TABLE:

ip_addr=DNS_TABLE[domain]

response=ip_addr.encode('utf-8')

else:

response=b'Not found'

return response

def run_dns_server(data):

sock=socket.socket(socket.AF_INET,sock.SOCK_STREAM)

sock.bind((HOST,PORT))

sock.listen(1)

print(f'Lintening {HOST}:{PORT}')

while True:
 connection,client_addr=sock.accept()

try:

print(f'connection from {client_addr}')

data=connection.recv(1024)

if data:

response=handle_dns_server(data)

connection.sendall(response)

finally:

connection.close()

run_dns_server()

--------------------------------------------------------------------------------

Client Code:

dns_client-tcp

import socket

SERVER_HOST='127.0.0.1'

SERVER_PORT=53

def run_dns_client():

sock=socket.socket(socket.AF_INET,sock.SOCK_STREAM)

sock.connect((SERVER_HOST,SERVER_HOST))

while True:

domain=input("Enter domain name:")

if domain=='q':

break

sock.sendall(domain.encode('utf-8'))

data=sock.recv(1024)

if data:

response=data.decode('utf-8')

print(f'Response:{response}')

sock.close()

run_dns_client()
----------------------------------------------------------------------------

server-crc

--------------------------------------------------------------

#include<iostream>

#include<cstring>

#include<string>

#define CRC_POLY 0xEDB888320

using namespace std;

unsigned int cal_crc(const char* data,size_t size){

unsigned int crc=0xFFFFFFFF;

for(size_t i=0;i<size;i++){

crc ^=data[i];

for(int j=0;j<8;j++){

if(crc&1){

crc=(crc>>1)^CRC_POLY;

else{

crc>>=1;

return ~crc;

int main(){

char data[100];

unsigned int crc;

cout<<"Server: Enter the data:";

cin.getline(data,strlen(data));

crc=cal_crc(data,strlen(data));

sprintf(data+strlen(data),"%08X",crc);

cout<<"server sending the data: "<<data<<endl;

--------------------------------------------------------------------------------------

client-crc

-----------------------------------------------------------------------------------------

#include<iostream>

#include<cstring>

#include<string>

#define CRC_POLY 0xEDB888320

using namespace std;

unsigned int cal_CRC(const char* data,size_t size){

unsigned int crc=0xFFFFFFFF;

for(size_t i=0;i<size;i++){

crc ^=data[i];

for(int j=0;j<8;j++){

if(crc&1){

crc=(crc>>1)^CRC_POLY;

else{

crc>>=1;

return ~crc;

int main(){

char data[100];

unsigned int crc,ReceivedCRC;

cout<<"client:Enter the data with CRC:";

cin.getline(data,sizeof(data));

sscanf(data+strlen(data)-8,"%X",&ReceivedCRC);
 crc=cal_CRC(data,strlen(data)-8);

if(crc=ReceivedCRC){

cout<<"Succesfull"<<endl;

else{

cout<<"Unsuccessful"<<endl;

return 0;

--------------------------------------------------------------------------------

tcp/ip server side

----------------------------------------------------------------------------

#include <stdio.h>

#include <netdb.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <string.h>

#include <sys/socket.h>

#include <sys/types.h>

#include <unistd.h>

#define MAX 80

#define PORT 8080

#define SA struct sockaddr

void func(int connfd)

char buff[MAX];

int n;

for (;;) {

bzero(buff, MAX);

read(connfd, buff, sizeof(buff));

bzero(buff, MAX);

n = 0;

while ((buff[n++] = getchar()) != '\n')

write(connfd, buff, sizeof(buff));

if (strncmp("exit", buff, 4) == 0) {

printf("Server Exit...\n");

break;

int main()

int sockfd, connfd, len;

struct sockaddr_in servaddr, cli;

sockfd = socket(AF_INET, SOCK_STREAM, 0);

if (sockfd == -1) {

printf("socket creation failed...\n");

exit(0);

else

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

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(PORT);

if ((bind(sockfd, (SA*)&servaddr, sizeof(servaddr))) != 0) {

exit(0);

else

printf("Socket successfully binded..\n");

if ((listen(sockfd, 5)) != 0) {

printf("Listen failed...\n");

exit(0);

else

printf("Server listening..\n");

len = sizeof(cli);

connfd = accept(sockfd, (SA*)&cli, &len);

if (connfd < 0) {

printf("server accept failed...\n");

exit(0);

else

printf("server accept the client...\n");

func(connfd);

close(sockfd);

----------------------------------------------------------------------------------

client side tcp/ip

----------------------------------------------------------------------------------

#include <arpa/inet.h>

#include <netdb.h>
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <sys/socket.h>

#include <unistd.h>

#define MAX 80

#define PORT 8080

#define SA struct sockaddr

void func(int sockfd)

char buff[MAX];

int n;

for (;;) {

bzero(buff, sizeof(buff));

printf("Enter the string : ");

n = 0;

while ((buff[n++] = getchar()) != '\n')

write(sockfd, buff, sizeof(buff));

bzero(buff, sizeof(buff));

read(sockfd, buff, sizeof(buff));

printf("From Server : %s", buff);

if ((strncmp(buff, "exit", 4)) == 0) {

printf("Client Exit...\n");

break;

int main()
{

int sockfd, connfd;

struct sockaddr_in servaddr, cli;

sockfd = socket(AF_INET, SOCK_STREAM, 0);

if (sockfd == -1) {

printf("socket creation failed...\n");

exit(0);

else

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

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

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

servaddr.sin_port = htons(PORT);

if (connect(sockfd, (SA*)&servaddr, sizeof(servaddr))

!= 0) {

printf("connection with the server failed...\n");

exit(0);

else

printf("connected to the server..\n");

// function for chat

func(sockfd);

// close the socket

close(sockfd);

}
-----------------------------------------------------------------------------------

udp server side

-----------------------------------------------------------------------------------

#include <stdio.h>

#include <string.h>

#include <sys/socket.h>

#include <arpa/inet.h>

int main(void){

int socket_desc;

struct sockaddr_in server_addr, client_addr;

char server_message[2000], client_message[2000];

int client_struct_length = sizeof(client_addr);

// Clean buffers:

memset(server_message, '\0', sizeof(server_message));

memset(client_message, '\0', sizeof(client_message));

// Create UDP socket:

socket_desc = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

if(socket_desc < 0){

printf("Error while creating socket\n");

return -1;

printf("Socket created successfully\n");

// Set port and IP:

server_addr.sin_family = AF_INET;

server_addr.sin_port = htons(2000);

server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
// Bind to the set port and IP:

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

printf("Couldn't bind to the port\n");

return -1;

printf("Done with binding\n");

printf("Listening for incoming messages...\n\n");

// Receive client's message:

if (recvfrom(socket_desc, client_message, sizeof(client_message), 0,

(struct sockaddr*)&client_addr, &client_struct_length) < 0){

printf("Couldn't receive\n");

return -1;

printf("Received message from IP: %s and port: %i\n",

inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

printf("Msg from client: %s\n", client_message);

// Respond to client:

strcpy(server_message, client_message);

if (sendto(socket_desc, server_message, strlen(server_message), 0,

(struct sockaddr*)&client_addr, client_struct_length) < 0){

printf("Can't send\n");

return -1;

// Close the socket:

return 0;

--------------------------------------------------------------------------------------------

udp client side

--------------------------------------------------------------------------------------------

#include <stdio.h>

#include <string.h>

#include <sys/socket.h>

#include <arpa/inet.h>

int main(void){

int socket_desc;

struct sockaddr_in server_addr;

char server_message[2000], client_message[2000];

int server_struct_length = sizeof(server_addr);

// Clean buffers:

memset(server_message, '\0', sizeof(server_message));

memset(client_message, '\0', sizeof(client_message));

// Create socket:

socket_desc = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

if(socket_desc < 0){

printf("Error while creating socket\n");

return -1;

printf("Socket created successfully\n");

server_addr.sin_family = AF_INET;

server_addr.sin_port = htons(2000);

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

// Get input from the user:

printf("Enter message: ");

gets(client_message);

// Send the message to server:

if(sendto(socket_desc, client_message, strlen(client_message), 0,

(struct sockaddr*)&server_addr, server_struct_length) < 0){

printf("Unable to send message\n");

return -1;

// Receive the server's response:

if(recvfrom(socket_desc, server_message, sizeof(server_message), 0,

(struct sockaddr*)&server_addr, &server_struct_length) < 0){

printf("Error while receiving server's msg\n");

return -1;

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

// Close the socket:

close(socket_desc);

return 0;

----------------------------------------------------------------------------------------
dns server udp

----------------------------------------------------------------------------------------

import socket

dns_server_addr='localhost'

dns_server_port=12000

dns_server_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

dns_server_socket.bind((dns_server_addr,dns_server_port))

print('Server is ready to use')

ip_addr_mapping={

'www.google.com':'192.178.11.0',

'www.example.com':'168.111.12.0'

while True:

query_message,client_addr=dns_server_socket.recvfrom(1024)

query_message=query_message.decode()

domain_name=query_message.split()[0]

if domain_name in ip_addr_mapping:

ip_addr=ip_addr_mapping[domain_name]

response_message=f'{ip_addr}:{domain_name}'

else:

response_message=f'Error'

dns_server_socket.sendto(response_message.encode(),client_addr)

-----------------------------------------------------------------------------

dns client udp

----------------------------------------------------------------------------

import socket

dns_server_addr='localhost'

dns_server_port=12000

dns_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

domain_name=input('Enter the domain name: ')

query_message=f'{domain_name}'
dns_client_socket.sendto(query_message.encode,(dns_server_addr,dns_server_port))

response_message,server_addr=dns_client_socket.recvfrom(1024)

response_message=response_message.decode()

print(response_message)

---------------------------------------------------------------------------