Computer Networks Interview Questions Explained — TCP, DNS, HTTP and Beyond

import socket
import struct

# This demo shows Layer 3 (Network) and Layer 4 (Transport) in action
# We're manually building a TCP connection and sending an HTTP request
# so you can SEE the layers working together

def demonstrate_osi_layers():
    target_host = "example.com"
    target_port = 80  # Layer 4 (Transport): port number identifies the service

    # Layer 3 (Network): DNS resolves the hostname to an IP address
    # This is where 'example.com' becomes '93.184.216.34'
    resolved_ip = socket.gethostbyname(target_host)
    print(f"[Layer 3 - Network]   Resolved '{target_host}' -> IP: {resolved_ip}")

    # Layer 4 (Transport): We create a TCP socket
    # TCP guarantees delivery and ordering — unlike UDP which is fire-and-forget
    tcp_socket = socket.socket(
        socket.AF_INET,    # Address Family: IPv4 (Layer 3)
        socket.SOCK_STREAM # Socket Type: TCP stream (Layer 4)
    )

    print(f"[Layer 4 - Transport] Opening TCP connection to {resolved_ip}:{target_port}")
    tcp_socket.connect((resolved_ip, target_port))
    print(f"[Layer 4 - Transport] TCP 3-way handshake complete (SYN -> SYN-ACK -> ACK)")

    # Layer 7 (Application): HTTP is the application protocol
    # Notice how HTTP doesn't know or care about TCP internals
    # That's the beauty of OSI layer separation
    http_request = (
        f"GET / HTTP/1.1\r\n"
        f"Host: {target_host}\r\n"
        f"Connection: close\r\n"
        f"\r\n"
    )

    print(f"[Layer 7 - Application] Sending HTTP GET request...")
    tcp_socket.sendall(http_request.encode('utf-8'))

    # Receive the first 512 bytes of the response
    raw_response = tcp_socket.recv(512)
    response_text = raw_response.decode('utf-8', errors='replace')

    # Extract just the HTTP status line (first line of the response)
    status_line = response_text.split('\r\n')[0]
    print(f"[Layer 7 - Application] HTTP Response: {status_line}")

    tcp_socket.close()
    print(f"[Layer 4 - Transport] TCP connection closed (FIN -> FIN-ACK)")

demonstrate_osi_layers()

import socket
import threading
import time

# ─────────────────────────────────────────────
# TCP SERVER: Reliable, connection-oriented
# Use when: data integrity matters (APIs, file transfer, chat messages)
# ─────────────────────────────────────────────
def run_tcp_server(host='127.0.0.1', port=9001):
    tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    tcp_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    tcp_server.bind((host, port))
    tcp_server.listen(1)  # Queue up to 1 connection
    print(f"[TCP Server] Listening on {host}:{port}")

    client_socket, client_address = tcp_server.accept()
    print(f"[TCP Server] Connection established with {client_address}")

    # TCP guarantees this message arrives in full, in order
    received_data = client_socket.recv(1024).decode('utf-8')
    print(f"[TCP Server] Received: '{received_data}'")
    client_socket.send(b"TCP ACK: Message received intact")

    client_socket.close()
    tcp_server.close()

# ─────────────────────────────────────────────
# UDP SERVER: Fast, connectionless
# Use when: speed matters more than reliability (video streams, game state, DNS)
# ─────────────────────────────────────────────
def run_udp_server(host='127.0.0.1', port=9002):
    udp_server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # SOCK_DGRAM = UDP
    udp_server.bind((host, port))
    print(f"[UDP Server] Listening on {host}:{port}")

    # No .accept() call — UDP has no connection concept
    received_data, sender_address = udp_server.recvfrom(1024)
    print(f"[UDP Server] Datagram from {sender_address}: '{received_data.decode()}'")
    # UDP CAN reply, but there's no guarantee the client gets it
    udp_server.sendto(b"UDP reply: no delivery guarantee", sender_address)
    udp_server.close()

def run_tcp_client(host='127.0.0.1', port=9001):
    time.sleep(0.1)  # Give server time to start
    tcp_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    tcp_client.connect((host, port))  # This triggers the 3-way handshake
    tcp_client.send(b"Hello via TCP — this WILL arrive")
    response = tcp_client.recv(1024)
    print(f"[TCP Client] Server replied: '{response.decode()}'")
    tcp_client.close()

def run_udp_client(host='127.0.0.1', port=9002):
    time.sleep(0.1)  # Give server time to start
    udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    # No .connect() required — we just fire and hope
    udp_client.sendto(b"Hello via UDP — no handshake needed", (host, port))
    response, _ = udp_client.recvfrom(1024)
    print(f"[UDP Client] Server replied: '{response.decode()}'")
    udp_client.close()

# Run both demos side by side
tcp_server_thread = threading.Thread(target=run_tcp_server, daemon=True)
udp_server_thread = threading.Thread(target=run_udp_server, daemon=True)

tcp_server_thread.start()
udp_server_thread.start()

run_tcp_client()
run_udp_client()

tcp_server_thread.join(timeout=2)
udp_server_thread.join(timeout=2)
print("\nKey difference: TCP needed a handshake. UDP just sent.")

import socket
import dns.resolver  # pip install dnspython
import time

# This script traces DNS resolution for a domain
# and shows TTL values — the caching mechanism that makes DNS scalable

def trace_dns_resolution(domain_name: str):
    print(f"\n{'='*55}")
    print(f" DNS Resolution Trace for: {domain_name}")
    print(f"{'='*55}")

    # Step 1: Check what the OS resolver returns
    # This uses your system's /etc/resolv.conf or Windows DNS settings
    start_time = time.time()
    os_resolved_ip = socket.gethostbyname(domain_name)
    resolution_time_ms = (time.time() - start_time) * 1000
    print(f"\n[OS Resolver]")
    print(f"  Resolved IP : {os_resolved_ip}")
    print(f"  Time taken  : {resolution_time_ms:.2f}ms (includes cache check)")

    # Step 2: Use dnspython to get detailed DNS record information
    # This bypasses the OS cache and queries the resolver directly
    resolver = dns.resolver.Resolver()
    resolver.nameservers = ['8.8.8.8']  # Use Google's public DNS

    print(f"\n[A Record Query via 8.8.8.8 (Google DNS)]")
    try:
        answer = resolver.resolve(domain_name, 'A')  # 'A' record = IPv4 address
        for record in answer:
            print(f"  IP Address : {record.address}")
            print(f"  TTL        : {answer.ttl} seconds")
            print(f"  Meaning    : This record is cached for {answer.ttl // 60} min {answer.ttl % 60} sec")
    except dns.resolver.NXDOMAIN:
        print(f"  Domain '{domain_name}' does not exist in DNS.")

    # Step 3: Query for CNAME records (common for CDNs like CloudFront)
    print(f"\n[CNAME Record Query — used by CDNs and load balancers]")
    try:
        cname_answer = resolver.resolve(domain_name, 'CNAME')
        for record in cname_answer:
            print(f"  CNAME Target : {record.target}")
            print(f"  (This domain is an alias — follow the chain to get the real IP)")
    except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN):
        print(f"  No CNAME record — this domain maps directly to an IP.")

    # Step 4: Query MX records (email routing)
    print(f"\n[MX Record Query — controls where email is delivered]")
    try:
        mx_answer = resolver.resolve(domain_name, 'MX')
        for record in mx_answer:
            print(f"  Mail Server : {record.exchange} (priority: {record.preference})")
    except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN):
        print(f"  No MX records found.")

    print(f"\n[Summary]")
    print(f"  Domain  : {domain_name}")
    print(f"  Final IP: {os_resolved_ip}")
    print(f"  Tip     : Lower TTL before changing IPs. Higher TTL = faster performance.")

# Run the trace on a well-known domain
trace_dns_resolution("github.com")

import ipaddress
import http.client
import ssl

# ─────────────────────────────────────────────────────
# PART 1: Subnet Calculator
# Understanding subnets is crucial for cloud and network interviews
# ─────────────────────────────────────────────────────
def explain_subnet(cidr_notation: str):
    print(f"\n{'='*50}")
    print(f" Subnet Analysis: {cidr_notation}")
    print(f"{'='*50}")

    network = ipaddress.IPv4Network(cidr_notation, strict=False)

    print(f"  Network Address  : {network.network_address}")
    print(f"  Broadcast Address: {network.broadcast_address}")
    print(f"  Subnet Mask      : {network.netmask}")
    print(f"  Prefix Length    : /{network.prefixlen}")
    print(f"  Total Hosts      : {network.num_addresses}")
    print(f"  Usable Hosts     : {network.num_addresses - 2} (subtract network & broadcast)")

    # Show the first 3 and last usable host addresses
    all_hosts = list(network.hosts())  # .hosts() excludes network and broadcast
    if len(all_hosts) >= 3:
        print(f"  First Usable IP  : {all_hosts[0]}")
        print(f"  Second Usable IP : {all_hosts[1]}")
        print(f"  Last Usable IP   : {all_hosts[-1]}")

    # Check if specific IPs are in this subnet
    test_ip = ipaddress.IPv4Address('192.168.1.150')
    print(f"  Is {test_ip} in subnet? {test_ip in network}")

# ─────────────────────────────────────────────────────
# PART 2: HTTP Status Code Classifier
# Know the MEANING, not just the number
# ─────────────────────────────────────────────────────
def classify_http_status(status_code: int) -> str:
    status_families = {
        1: "1xx Informational — request received, processing continues",
        2: "2xx Success — request successfully received, understood, and accepted",
        3: "3xx Redirection — further action needed to complete the request",
        4: "4xx Client Error — the REQUEST has bad syntax or cannot be fulfilled",
        5: "5xx Server Error — the SERVER failed to fulfil a valid request"
    }
    family = status_code // 100
    return status_families.get(family, "Unknown status code family")

def demonstrate_http_vs_https():
    print(f"\n{'='*50}")
    print(" HTTP vs HTTPS Connection Demo")
    print(f"{'='*50}")

    # HTTP connection — plaintext, no encryption
    print("\n[HTTP - Port 80, NO encryption]")
    http_conn = http.client.HTTPConnection("example.com", timeout=5)
    http_conn.request("HEAD", "/")  # HEAD request: only headers, no body
    http_response = http_conn.getresponse()
    print(f"  Status: {http_response.status} — {classify_http_status(http_response.status)}")
    print(f"  Server: {http_response.getheader('Server', 'Not disclosed')}")
    print(f"  ⚠️  All data transmitted in PLAINTEXT — visible to anyone sniffing the network")
    http_conn.close()

    # HTTPS connection — encrypted with TLS
    print("\n[HTTPS - Port 443, TLS encrypted]")
    # ssl.create_default_context() loads trusted Certificate Authorities
    tls_context = ssl.create_default_context()
    https_conn = http.client.HTTPSConnection("example.com", context=tls_context, timeout=5)
    https_conn.request("HEAD", "/")
    https_response = https_conn.getresponse()
    print(f"  Status: {https_response.status} — {classify_http_status(https_response.status)}")
    print(f"  TLS Version: {https_conn.sock.version()}")
    print(f"  Cipher Suite: {https_conn.sock.cipher()[0]}")
    print(f"  ✅ All data encrypted — intercepted traffic is gibberish without the key")
    https_conn.close()

# Run all demos
explain_subnet("192.168.1.0/24")
explain_subnet("10.0.0.0/16")

print(f"\n{'='*50}")
print(" HTTP Status Code Reference")
print(f"{'='*50}")
for code in [200, 201, 301, 304, 400, 401, 403, 404, 429, 500, 502, 503]:
    print(f"  {code}: {classify_http_status(code).split('—')[0].strip()}")

demonstrate_http_vs_https()