Network Layer Protocol Practice Questions

In link-state routing, every individual router computes its own path to all destinations based on the shared link-state database. Consequently, each router must maintain its own independent routing table to determine packet forwarding decisions. Given that there are $5$ routers in the intranet, each router hosts exactly one local routing table. The number of networks ($6$) influences the table's content but not the quantity of tables. Thus, the total number of routing tables is equal to the number of routers, which is $5$.

The IPv4 address range from $224.0.0.0$ to $239.255.255.255$ is classified as Class D. In binary notation, these addresses begin with the bit pattern $1110_2$. According to IANA standards, this entire block is reserved specifically for IP multicast communication, where a single packet is transmitted to a group of interested hosts. Other options are incorrect: $127.0.0.0/8$ is for loopback, $255.255.255.255$ is the limited broadcast address, and the range starting at $240.0.0.0$ (Class E) is reserved for future or experimental use. Thus, this specific range facilitates multicast operations.

The Time-to-Live ($TTL$) field is an $8$-bit value in the IP header that specifies the maximum number of hops a packet can take before being discarded. Every router that forwards the datagram decrements the $TTL$ value by $1$. If the value reaches $0$, the router drops the packet and notifies the source. This mechanism is essential to prevent packets from circulating indefinitely in the network due to cyclic routing paths or misconfigured routing tables, ensuring network resources are not exhausted by infinite loops.

To determine if two computers are on the same network, each calculates the network ID of the other using its own netmask.

C1's network ID is $203.197.2.53 \ \& \ 255.255.128.0 = 203.197.0.0$. Checking C2, C1 computes $203.197.75.201 \ \& \ 255.255.128.0 = 203.197.0.0$. Since both match, C1 assumes C2 is on the same network.

C2's network ID is $203.197.75.201 \ \& \ 255.255.192.0 = 203.197.64.0$. Checking C1, C2 computes $203.197.2.53 \ \& \ 255.255.192.0 = 203.197.0.0$. Because the network IDs ($203.197.64.0$ vs $203.197.0.0$) differ, C2 assumes C1 is on a different network.

Therefore, C1 assumes C2 is on the same network, while C2 assumes C1 is on a different network.

To determine the correct interface, we perform a bitwise AND operation between the destination IP $144.16.68.117$ and each subnet mask to find the matching network:

1. $144.16.68.117 \ \& \ 255.255.0.0 = 144.16.0.0$ (matches $eth0$, $/16$)
2. $144.16.68.117 \ \& \ 255.255.224.0 = 144.16.64.0$ (matches $eth1$, $/19$)
3. $144.16.68.117 \ \& \ 255.255.255.0 = 144.16.68.0$ (matches $eth2$, $/24$)
4. $144.16.68.117 \ \& \ 255.255.255.224 = 144.16.68.96 \neq 144.16.68.64$ (no match for $eth3$)
   The longest prefix match is the entry with the most specific mask, which is $eth2$ with a $/24$ subnet mask.

The third octet of the broadcast address $144.16.95.255$ is $95$, which is $01011111_2$ in binary.
A subnet mask $255.255.M.0$ defines host bits in the third octet where the mask has $0$s, and for a broadcast address, these host bits must all be $1$s.
For $255.255.224.0$ ($M=11100000_2$), the last 5 bits are host bits, which are all $1$s in $01011111_2$.
For $255.255.240.0$ ($M=11110000_2$), the last 4 bits are host bits, which are all $1$s in $01011111_2$.
For $255.255.248.0$ ($M=11111000_2$), the last 3 bits are host bits, which are all $1$s in $01011111_2$.
Because each mask configuration allows the broadcast address third octet to be $95$, any of these masks could be valid.

A class B network starts with 16 bits for the network ID. To support 64 subnets, we need to borrow $n$ bits such that $2^n \ge 64$, resulting in $n=6$.
The new subnet mask length becomes $16 + 6 = 22$ bits.
In binary, this is represented as $11111111.11111111.11111100.00000000$.
Converting the third octet $11111100_2$ to decimal results in $128 + 64 + 32 + 16 + 8 + 4 = 252$.
Consequently, the subnet mask is 255.255.252.0.

To determine the routing table for node $B$, we calculate the shortest path to all other nodes using distance vector routing (unit costs):

1. Direct Neighbors: Node $B$ is connected directly to $A$, $C$, and $D$. Thus, costs to $A$, $C$, and $D$ are all $1$, with next hops $A$, $C$, and $D$ respectively.
2. Node $E$: The shortest path is via $C$ ($B \rightarrow C \rightarrow E$) or $D$ ($B \rightarrow D \rightarrow E$), with a total cost of $1 + 1 = 2$. Option $C$ indicates next hop $C$ with cost $2$, which is valid.
3. Node $F$: The shortest path is $B \rightarrow D \rightarrow F$ with a total cost of $1 + 1 = 2$. Option $C$ indicates next hop $D$ with cost $2$, which is valid.

Comparing these results with the table provided in Option $C$, we see a perfect match for the shortest path calculations.

Distance vector routing protocols, such as RIP, utilize the Bellman-Ford algorithm where routers only share their distance vector table with immediate neighbors. When a link fails, a router may erroneously update its routing table using stale information from a neighbor, believing a path exists through them. This triggers a loop where the cost or hop count increments indefinitely (e.g., $1 \to 2 \to 3 \dots \to \infty$) as routers continuously propagate inaccurate information to one another. Link-state protocols avoid this by sharing full topology maps, making the "count to infinity" problem specific to distance vector routing.

In Distance Vector routing without Split Horizon, when node A fails, neighbors B and C create a routing loop. B incorrectly assumes it can reach A via C with cost $1 + \text{cost}(C,A)$, and C assumes it can reach A via B with cost $1 + \text{cost}(B,A)$. This triggers a count-to-infinity behavior where the cost for B and C to reach A increments by $1$ in each update interval. As the path from F to A is relayed through these nodes, F's routing table also reflects this increasing cost. By time $t+100$, the cost has incremented roughly $100$ times; since it has not yet reached the protocol's defined $\infty$, the cost remains a finite value greater than $100$.

To accommodate $100$ hosts, we require a subnet mask of $255.255.255.128$ ($/25$), which provides $2^{7-}2 = 126$ usable hosts.
To accommodate $50$ hosts, we require a subnet mask of $255.255.255.192$ ($/26$), which provides $2^{6-}2 = 62$ usable hosts.
We must allocate one $/25$ block ($128$ addresses) and two $/26$ blocks ($64$ addresses each) to cover the network.
Option D assigns $204.204.204.128/255.255.255.128$ ($128-255$), $204.204.204.64/255.255.255.192$ ($64-127$), and $204.204.204.0/255.255.255.192$ ($0-63$).
This configuration covers the entire space without overlap and satisfies all host requirements.

Reverse DNS lookups utilize the special in-addr.arpa domain to map IP addresses to hostnames by reversing the byte order. For the IP address $145.128.16.8$, the lookup process traverses the hierarchical DNS tree starting from the root zone. The resolver initiates the process by querying the authoritative nameserver for the in-addr.arpa zone. It then follows the delegation path downward, traversing through intermediate sub-zones such as $128.145.\in-addr.arpa$ to identify the specific nameserver responsible for the target record. Consequently, querying in-addr.arpa followed by 128.145.in-addr.arpa constitutes a valid and appropriate subsequence of the lookup procedure.

The Address Resolution Protocol (ARP) is a fundamental networking protocol used to map a known logical $IP_{address}$ to a specific physical $MAC_{address}$ on a local network segment. When a host needs to communicate with a destination, it must encapsulate the packet in a frame, which requires the hardware $MAC_{address}$. By broadcasting an ARP request packet containing the target $IP_{address}$, the device obtains the corresponding $MAC_{address}$ from the target host's reply. This mechanism ensures valid data link layer delivery, proving that ARP translates an $IP$ address into a $MAC$ address.

In a bridged network, multiple physical paths between LANs can lead to loops, causing infinite frame circulation and broadcast storms. The Spanning Tree Algorithm (STA) ensures network stability by logically disabling redundant paths, effectively reducing the network topology to a tree structure. By forcing a single active path between any two nodes, the algorithm eliminates cyclical data transmission. Therefore, the primary purpose of using the spanning tree algorithm is for avoiding loops in the routing paths.

The subnet mask $255.255.255.192$ uses $26$ bits for the network portion, as the last octet $192$ is represented in binary as $11000000_2$.
Given a total of $32$ bits, the number of host bits $H$ is $32 - 26 = 6$.
The maximum number of usable hosts is calculated using the formula $2^H - 2$, which accounts for the network and broadcast addresses.
Substituting $H=6$, we get $2^6 - 2 = 64 - 2 = 62$.
Thus, there are $62$ assignable hosts in this subnet.

A transparent bridge operates at the Data Link Layer (Layer 2) of the OSI model, making forwarding decisions based on destination Media Access Control (MAC) addresses. In contrast, a router operates at the Network Layer (Layer 3) and makes routing decisions based on destination IP addresses. Option B is incorrect because it erroneously swaps these definitions, claiming the bridge uses IP addresses and the router uses MAC addresses. Since the question asks for the statement that is NOT true, B is the correct choice.

To calculate the total bytes delivered to the destination IP layer, we first determine the size of the IP packet. The application message consists of $180$ bytes of data plus a $20$-byte TCP header, totaling $200$ bytes. Including a $20$-byte IP header, the total IP packet size is $220$ bytes.

When this packet enters network B, which has a maximum transmission unit (MTU) of $100$ bytes, it must be fragmented. The maximum IP payload allowed in network B is $100 - 20 = 80$ bytes (which is a multiple of $8$). The $200$-byte payload is split as follows:

1. Fragment 1: $80$ bytes data + $20$ bytes IP header = $100$ bytes.
2. Fragment 2: $80$ bytes data + $20$ bytes IP header = $100$ bytes.
3. Fragment 3: $40$ bytes data + $20$ bytes IP header = $60$ bytes.

The total bytes delivered to the destination IP layer is the sum of these fragments: $100 + 100 + 60 = 260$ bytes.

The Internet Protocol (IP) header is responsible for Network Layer routing and contains fields such as the Fragment Offset, Source IP address, and Destination IP address to facilitate host-to-host delivery. In contrast, port numbers, such as the Destination port number, are defined in the Transport Layer headers (like TCP or UDP). These transport headers encapsulate the data to ensure it reaches the correct process or application on the destination host. Since port numbers reside in the transport segment rather than the IP datagram header, they are not part of the IP header.