BE Computer Engineering (Pokhara University) Computer Networks (PU, CMP 344) Question Paper 2079 Nepal

(a) OSI Reference Model vs TCP/IP Protocol Suite

Layer correspondence

The TCP/IP Application layer merges the three top OSI layers, and the TCP/IP Network Access layer merges the two bottom OSI layers; the Transport and Network/Internet layers map one-to-one.

(b) Encapsulation and Decapsulation

As data moves down the sender's stack, each layer adds its own header (and possibly trailer); the result is the layer's Protocol Data Unit (PDU). This is encapsulation. At the receiver, each layer strips off its corresponding header as data moves up the stack: this is decapsulation.

At the receiver the order reverses: Physical reassembles bits into a frame, Data Link removes the frame header/trailer, Network removes the IP header, Transport removes the TCP/UDP header and reorders/acknowledges, and finally the Application layer delivers the original message to the application process.

(c) Why the Internet uses TCP/IP rather than OSI

1. Protocols existed and worked first. TCP/IP was implemented and battle-tested on ARPANET before the OSI standard was completed, so it already had a deployed installed base; OSI protocols arrived late and were complex and rarely implemented.
2. Simplicity and efficiency. TCP/IP's 4-layer model is leaner — the OSI Session and Presentation layers were thinly used and their functions were absorbed into applications, making the OSI model bloated for real use.
3. Free, open implementation. TCP/IP shipped with BSD UNIX at essentially no cost, accelerating adoption, whereas OSI implementations were heavy and vendor-tied.

(Any two well-justified reasons are sufficient.)

(a) VLSM Design for 192.168.20.0/24

Allocate subnets largest-first so the address space packs efficiently. For $h$ hosts we need the smallest prefix where $2^{(32-prefix)} - 2 \ge h$.

Allocation table

(b) Unused address space

Used addresses: 64 + 32 + 16 + 16 + 8 = 136 addresses (192.168.20.0 – .135).

Remaining: addresses 192.168.20.136 – 192.168.20.255 = 120 addresses are unused and available for future growth (e.g. a free /25-worth of space starting from .136, allocatable as a /26 at .192, a /27 at .160, etc.).

(c) Why VLSM is more efficient than fixed-length subnetting

With fixed-length subnetting, every subnet must use the same mask sized for the largest requirement. The largest department (50 hosts) needs a /26 (64 addresses). Forcing all five subnets to /26 consumes $5 \times 64 = 320$ addresses — more than the 256 a /24 even contains, so it is impossible, and even rounding the count of needed subnets up to 8 wastes huge ranges (a 6-host subnet would still get 64 addresses).

VLSM lets each subnet take a mask sized to its own need, so a 6-host department uses only a /29 (8 addresses) instead of a /26. This minimizes waste, fits all five departments inside the single /24, and leaves 120 addresses free for future use.

(a) Distance-Vector vs Link-State Routing

(b) Dijkstra's Algorithm from node A

Links: A-B=2, A-C=5, B-C=1, B-D=7, C-D=3, D-E=1, C-E=6.

Let $D(v)$ = current shortest known distance from A. Start: $D(A)=0$, all others $=\infty$. Let S = set of finalized nodes.

At each step the unfinalized node with the smallest $D$ is selected and its neighbours are relaxed.

Resulting routing table at A

(c) Count-to-Infinity Problem and a Mitigation

Problem: In distance-vector routing, when a link or node fails, routers can keep believing a stale route advertised back to them by a neighbour. Each exchange increments the metric by one as routers update each other based on outdated information, so the cost slowly "counts up" toward infinity instead of immediately recognizing the route is dead. This causes routing loops and slow convergence.

Mitigation — Split Horizon (with Poison Reverse):

• Split horizon: a router never advertises a route back out the same interface from which it learned that route, preventing a neighbour from re-teaching a router its own stale path.
• Poison reverse strengthens this by advertising the route back with an infinite metric (16 in RIP), explicitly telling the neighbour "do not route through me to reach this destination."

(Other valid mitigations: route poisoning, hold-down timers, triggered updates, or capping the maximum hop count at 16.)

(a) TCP Three-Way Handshake

Used to synchronize sequence numbers and establish a connection before data transfer.

1. SYN: Client → Server with SYN=1, sequence number seq=x (client's initial sequence number, ISN).
2. SYN-ACK: Server → Client with SYN=1, ACK=1, seq=y (server ISN) and ack=x+1 (acknowledging the client's SYN).
3. ACK: Client → Server with ACK=1, seq=x+1, ack=y+1 (acknowledging the server's SYN).

After these three messages both sides have agreed initial sequence numbers and the connection is ESTABLISHED.

(b) Reliable, In-Order Delivery

• Sequence numbers: every byte is numbered, so the receiver can detect lost, duplicate, or out-of-order segments and reorder them before delivering to the application.
• Acknowledgements (ACKs): the receiver sends cumulative ACKs (ack = next expected byte), confirming all data received up to that point.
• Retransmission timers: the sender starts a timer for sent data; if the ACK does not arrive before the Retransmission Timeout (RTO) (derived from estimated RTT), the segment is retransmitted. Fast retransmit retransmits immediately on three duplicate ACKs without waiting for the timer. Together these guarantee that every byte eventually arrives, exactly once, in order.

(c) Flow Control (Sliding Window) vs Congestion Control

Flow control prevents a fast sender from overwhelming a slow receiver. The receiver advertises a receive window (rwnd) in every ACK — the amount of free buffer it has. The sender may have at most rwnd unacknowledged bytes outstanding.

Example: Receiver advertises rwnd = 4000 bytes with 1000-byte segments. The sender can send up to 4 segments (the "window") before stopping. As the application reads data and frees buffer, the receiver advertises a larger window and the window slides forward, allowing more transmission.

Contrast with congestion control: congestion control protects the network (routers/links), not the receiver. TCP maintains a separate congestion window (cwnd) adjusted by algorithms like slow start and congestion avoidance (AIMD), reacting to packet loss as a signal of congestion. The actual amount a sender may transmit is $\min(rwnd, cwnd)$ — flow control guards the endpoint, congestion control guards the path.

(d) Two scenarios where UDP is preferred over TCP

1. Real-time voice/video (VoIP, live streaming, online gaming): low latency matters more than reliability; retransmitting a late audio/video packet is useless, so UDP's no-handshake, no-retransmission behavior avoids delay and jitter.
2. DNS lookups (and other short request/response queries): a query and reply fit in one or two packets; UDP avoids the overhead of TCP connection setup/teardown, making lookups fast and lightweight. (Also valid: DHCP, SNMP, multicast/broadcast applications.)

Domain Name System (DNS)

DNS is a distributed, hierarchical naming system (an Application-layer service running over UDP/TCP port 53) that translates human-readable hostnames into IP addresses. The namespace is organized as a tree: root → top-level domains (TLDs) like .np → second-level domains like edu.np → hosts like www.pu.edu.np. Resolution is handled by a local/recursive resolver, the root servers, TLD servers, and authoritative name servers.

Query types

• Recursive query: the client asks its local DNS resolver for the full answer; the resolver takes responsibility for contacting other servers and returns the final IP.
• Iterative query: a server, instead of fully resolving, returns a referral to the next server to ask. The local resolver typically uses iterative queries up the hierarchy.

Resolving www.pu.edu.np (text diagram)

Client                 Local DNS Resolver           Hierarchy
  | --(1) recursive: www.pu.edu.np?--> |
  |                                    | --(2)--> Root server
  |                                    | <--(3)-- referral to .np TLD server
  |                                    | --(4)--> .np TLD server
  |                                    | <--(5)-- referral to edu.np / pu.edu.np NS
  |                                    | --(6)--> pu.edu.np authoritative NS
  |                                    | <--(7)-- IP address of www.pu.edu.np
  | <--(8) final answer (IP)-----------|

Steps:

1. Client sends a recursive query to its local resolver. 2-7. The resolver performs iterative queries: it asks a root server (which refers it to the .np TLD server), then the .np server (which refers it to the authoritative server for pu.edu.np), then the authoritative server, which returns the actual IP address.
2. The resolver returns the final IP to the client and caches it (per the record's TTL) so subsequent lookups are fast.

(a) Non-persistent vs Persistent HTTP

For a web page with one HTML file plus 10 images, non-persistent HTTP opens 11 connections; persistent HTTP serves all 11 objects over one connection.

(b) Role of Cookies in Stateless HTTP

HTTP is stateless — each request is independent and the server keeps no memory of previous requests from the same client. Cookies add state on top of this: the server sends a small identifier that the browser stores and returns on every subsequent request, letting the server recognize a returning client and maintain a session.

Mechanism:

1. On first response, the server sends a Set-Cookie: sessionID=12345 header.
2. The browser stores it and includes Cookie: sessionID=12345 in every later request to that site.
3. The server uses the ID as a key into its back-end database to recall that user's state.

E-commerce example: A user visits an online store; the server sets sessionID=12345. As the user adds items to the cart, the browser returns this cookie with each request, so the server links every action to the same session and keeps the shopping cart populated across page views. At checkout, the same cookie identifies the logged-in user so their address and cart persist — without cookies, each click would look like a brand-new anonymous visitor and the cart would be empty.

Hub vs Switch vs Router

Key points

• A hub simply repeats every incoming signal to all other ports, causing collisions and wasting bandwidth (half-duplex).
• A switch learns which MAC address is on which port and forwards a frame only to the destination port, eliminating collisions per port while still passing broadcasts.
• A router connects different IP networks, makes forwarding decisions on destination IP, and stops broadcasts, thereby segmenting broadcast domains.

Deployment in a campus network

• Hub: essentially obsolete; at most used for a tiny legacy segment or as a passive monitoring tap — generally avoided.
• Switch: the workhorse of the access and distribution layers — connecting end devices (PCs, printers, APs) within a building/floor and providing wire-speed L2 connectivity, often with VLANs.
• Router: deployed at the network edge / core to interconnect different subnets (e.g. departments) and to connect the campus LAN to the Internet/WAN, providing inter-VLAN routing and security boundaries.

(a) Hidden Terminal Problem

In a wireless LAN, nodes have limited radio range. Consider three stations: A — B — C, where A and C are both in range of the access point/station B, but A and C are out of range of each other.

When A transmits to B, station C cannot sense A's signal (A is "hidden" from C). If C also senses the medium as idle and transmits to B at the same time, the two signals collide at B, corrupting both frames. Neither A nor C is aware of the other — this is the hidden terminal (hidden node) problem. Ordinary carrier sensing fails because the collision happens at the receiver, not at either sender.

(b) CSMA/CA with RTS/CTS in IEEE 802.11

Wireless cannot detect collisions while transmitting (no full-duplex sensing), so 802.11 uses CSMA/CA — Carrier Sense Multiple Access with Collision Avoidance instead of CSMA/CD. A station senses the channel, waits for it to be idle for a DIFS interval plus a random backoff, then transmits, and relies on an ACK to confirm success.

To solve the hidden terminal problem specifically, 802.11 adds an optional RTS/CTS handshake:

1. RTS (Request To Send): Sender A sends a short RTS frame to B, containing the expected duration of the exchange.
2. CTS (Clear To Send): B replies with a CTS frame, also carrying the duration. Crucially, C is within range of B and hears this CTS.
3. NAV (Network Allocation Vector): Every station that hears the RTS or CTS — including the hidden node C — sets its NAV timer for the announced duration and defers transmitting (virtual carrier sensing).
4. DATA + ACK: A transmits the data frame; B replies with an ACK. Because C deferred based on the CTS, no collision occurs at B.

Thus RTS/CTS reserves the medium around the receiver through the CTS that hidden nodes can hear, eliminating hidden-terminal collisions at the cost of small control-frame overhead.

SNMP Architecture

The Simple Network Management Protocol (SNMP) is an Application-layer protocol (over UDP ports 161/162) used to monitor and manage network devices. It follows a manager-agent model.

Components

• Manager (Network Management Station, NMS): The central software/host that monitors and controls the network. It polls agents, processes responses, raises alarms, and presents data to administrators. It initiates Get/Set requests and receives Traps.

• Agent: Software running on each managed device (router, switch, server, printer). It maintains the device's local management data, responds to the manager's Get/Set requests, and autonomously sends Traps when significant events occur.

• Management Information Base (MIB): A hierarchical, standardized database of managed objects on each device (e.g. interface counters, CPU load, uptime). Each object is identified by a unique Object Identifier (OID) in a tree structure. The MIB defines what can be monitored or configured; the agent exposes these objects to the manager.

SNMP Messages

Operation summary

The manager polls agents using Get to read MIB values and uses Set to change device parameters; agents send Trap messages to alert the manager of events as they happen. Together these allow centralized fault, configuration, and performance management of the network.

(a) Virtual LAN (VLAN)

A VLAN is a logical grouping of network devices into a single broadcast domain, defined in switch software rather than by physical location. Ports on one or more switches can be assigned to the same VLAN so that they behave as if on a separate LAN, regardless of where the devices physically connect.

How VLANs segment a switched network:

• A single physical switch is partitioned into multiple logical broadcast domains, one per VLAN. A broadcast from a host in VLAN 10 reaches only other VLAN-10 ports, not VLAN-20 ports.
• This requires a router (or Layer-3 switch) to communicate between VLANs (inter-VLAN routing).

Benefits:

• Broadcast control: broadcasts are confined to their VLAN, reducing unnecessary traffic and improving performance.
• Security: devices in different VLANs are isolated at Layer 2; sensitive groups (e.g. Finance) can be separated from others, and inter-VLAN traffic can be filtered by an ACL on the router.
• Flexibility: users can be grouped by function rather than physical location.

(b) VLAN Trunking and IEEE 802.1Q

• VLAN trunking: A trunk is a single link (typically switch-to-switch or switch-to-router) that carries traffic for multiple VLANs simultaneously, instead of running one cable per VLAN. This lets VLANs span several switches.
• IEEE 802.1Q tagging: To keep VLAN traffic distinguishable on a shared trunk, 802.1Q inserts a 4-byte tag into each Ethernet frame's header containing a 12-bit VLAN ID (VID) (supporting up to 4094 VLANs) plus priority bits. The sending switch tags each frame with its VLAN ID before sending it on the trunk; the receiving switch reads the tag, forwards the frame within the correct VLAN, and removes the tag before delivering to an access port. This allows many VLANs to coexist on one physical trunk link.

UDP Header (8 bytes)

 0                   16                  31
+-------------------+-------------------+
|   Source Port     |  Destination Port |
+-------------------+-------------------+
|     Length        |     Checksum      |
+-------------------+-------------------+

Four 16-bit fields only: Source Port, Destination Port, Length, Checksum.

TCP Header (20 bytes minimum)

 0                   16                  31
+-------------------+-------------------+
|   Source Port     |  Destination Port |
+-------------------+-------------------+
|             Sequence Number           |
+---------------------------------------+
|         Acknowledgement Number        |
+----+------+-------+-------------------+
|HLen|Resvd | Flags |   Window Size     |   (Flags: URG ACK PSH RST SYN FIN)
+----+------+-------+-------------------+
|     Checksum      |  Urgent Pointer   |
+-------------------+-------------------+
|        Options (if any)  + Padding    |
+---------------------------------------+

Three fields present in TCP but absent in UDP

(Other valid TCP-only fields: Flags/control bits such as SYN/ACK/FIN, Urgent Pointer, Data-offset/HLen.)

(a) IPv4 vs IPv6 Addressing

(b) Two IPv4-to-IPv6 Transition Mechanisms

1. Dual Stack: A host or router runs both IPv4 and IPv6 protocol stacks simultaneously and is assigned both an IPv4 and an IPv6 address. It communicates with IPv4 peers using IPv4 and with IPv6 peers using IPv6, choosing the protocol per destination (often guided by DNS A vs AAAA records). It is the most straightforward path but requires devices to support both stacks.

2. Tunnelling (e.g. 6in4 / 6to4): When an IPv6 packet must cross an IPv4-only portion of the network, it is encapsulated inside an IPv4 packet at the entry of the IPv4 region and decapsulated at the exit, effectively carrying IPv6 traffic through an IPv4 "tunnel." This lets isolated IPv6 islands communicate over the existing IPv4 infrastructure.

(NAT64/DNS64 is also acceptable: it translates between IPv6-only and IPv4-only hosts so an IPv6 client can reach an IPv4 server.)