Summary
Highlights
The course sets out to cover the fundamental concepts and protocols of computer networking, exploring the entire networking stack from physical media to application layer protocols like HTTP and DNS. It will include technical mechanisms such as error detection through CRC, flow control, and advanced IPv4 addressing. The instructor outlines the curriculum, teaching methodology (raw pen and paper style with provided reading materials and daily practice problems), prerequisites (data structures and algorithms), and course benefits for GATE aspirants, university students, and job interview preparation. A bonus module on security will also be covered.
Subnet masks define the NID+SID portion of an IP address using ones, and the HID portion using zeros. Identifying the number of borrowed bits, subnets, and hosts per subnet requires converting subnet mask octets to binary and understanding their weights. When multiple bits are borrowed, their positions (contiguous or non-contiguous) in binary affect the actual subnet IDs. For instance, a subnet mask like 255.255.255.44 implies specific non-contiguous bit positions for the SID, derived from the binary representation of 44. The class of an IP address is crucial for determining NID/HID boundaries, which in turn influences subnetting calculations. Variable Length Subnet Masking (VLSM) addresses the inefficiency of fixed-size subnets in classful addressing. Instead of statically assigning subnet sizes, VLSM recursively divides subnets, allowing for different subnet sizes based on actual host requirements. This hierarchical subnetting technique optimizes IP address allocation by creating smaller subnets from larger ones, dynamically adjusting the NID/SID boundaries. Router behavior (longest prefix match) and the formula to extract subnet ID and host ID from an IP address using the subnet mask (IP address AND subnet mask for SID) are also crucial concepts.
Supernetting, or Route Aggregation, is the process of combining multiple smaller networks into a larger supernet. This reduces the number of routing table entries, making routing more efficient. Three conditions must be met for supernetting to be possible: the blocks to be combined must be contiguous, the number of blocks must be a power of two, and the resulting supernet's size (address range) must be divisible by the first block's ID. In supernetting, bits are 'borrowed' from the Network ID (NID) part of the IP address, effectively reducing the length of the NID and increasing the Host ID (HID) to create a larger network block. This is different from subnetting, which borrows bits from the HID. Consequently, a supernet mask (CIDR notation) will have fewer '1's than the original network masks, indicating a shorter NID/CIDR prefix. The supernet mask is less than the NID, unlike a subnet mask. Supernetting reduces routing table size but demands careful planning to avoid IP address conflicts.
Error control focuses on dealing with unintentional corruption of data during transmission due to noise. This course distinguishes between error detection and error correction. Detection only confirms the presence of an error, often leading to retransmission. Correction aims to identify the number and exact location of corrupted bits, allowing for precise restoration. Single-bit errors (one bit flips) and burst errors (two or more bits flip) are the two types. Burst errors are more common. Redundant bits, extra bits added to the data, are central to both detection and correction. Comparing these redundant bits at the receiver helps identify whether an error occurred. The Hamming distance, the number of differing bits between two binary strings, is a key concept. A minimum Hamming distance (dmin) of D allows detecting D-1 bit errors and correcting (D-1)/2 bit errors. For instance, if dmin=3, one-bit errors can be corrected, and two-bit errors can be detected.
Simple parity check adds one redundant bit (a parity bit) to each data word to make the total number of '1's either even (even parity) or odd (odd parity). It can detect all single-bit errors. However, it fails to detect an even number of errors, as the parity count would remain unchanged. It effectively detects all odd numbers of errors. 2D parity organizes data bits into a matrix, calculating parity bits for both rows and columns. This allows for detection and correction of all single-bit errors. In case of a single-bit error, the row and column parity checks will pinpoint the exact location of the error due to an intersection of detected parity failures. For two-bit and three-bit errors, 2D parity can detect them but usually cannot correct them, as multiple intersections make pinpointing the exact corrupted bits ambiguous. It primarily identifies errors by changes in parity bits. The method's disadvantage is its failure when errors occur directly within the parity bits themselves.
Cyclic Redundancy Check (CRC) is a robust error detection method. Unlike linear block codes, where redundant bits are added at the end, CRC utilizes polynomial arithmetic for detection. The sender starts with data and a pre-agreed divisor (CRC generator polynomial). It appends k-1 zeros to the data (where k is the divisor's length), performs a modulo-2 polynomial division, and obtains a remainder, which is the CRC. These appended zeros are then replaced by the calculated CRC, forming a codeword that's transmitted. The receiver performs the same modulo-2 division on the received codeword using the same divisor. If the remainder is zero, the data is accepted; otherwise, an error is detected, and retransmission is requested. This process relies on mathematical properties ensuring that if the data is corrupted during transmission, the remainder at the receiver's end will likely be non-zero.
Checksum is an error detection method that works by summing data blocks and transmitting this sum along with the data. The sender divides the original message into k blocks, each of n bits. It calculates the sum of all these blocks, adding any carry generated during the process back to the sum. The one's complement of this final sum is then computed and appended as the checksum block. At the receiver's end, all received blocks (including the checksum block) are summed in the same manner. If the final sum (after one's complement) is all ones, it signifies no error; otherwise, an error is detected. Checksum reliably detects all odd numbers of errors and most even numbers of errors (except in the rare case where errors perfectly cancel each other out, leaving the sum unchanged). Checksum in the IP header specifically refers to error checking for the header part only and is recalculated at every router due to changes in fields like TTL.
Flow control prevents a fast sender from overwhelming a slow receiver. Essential concepts include transmission delay (time taken to place a message on the link: message length/bandwidth), and propagation delay (time taken for the message to travel across the link: distance/speed). Unlike placing all bits simultaneously, bits are sent bit by bit, moving along the link as soon as they are placed (pipelining). Other delays include queuing delay (waiting time in a router's buffer) and processing delay (time taken by a router/receiver to process a packet). Accurate unit conversion is critical in these calculations (e.g., kilobits vs. kilobytes, 10^3 vs. 2^10). These delays occur across different layers of the OSI/TCP-IP model, with routers processing up to the network layer, while end hosts process up to the application layer. Flow control coordinates data transmission and acknowledgment to prevent data loss due to receiver overload or limited memory. Protocols achieve this by controlling the amount of data sent before an acknowledgment is received.
The Stop-and-Wait ARQ protocol is a fundamental flow control mechanism where the sender transmits one data packet and waits for its acknowledgment (ACK) before sending the next. This simplicity tackles several problems: lost data packets (sender sets a timer, retransmits if no ACK is received before timeout), lost acknowledgments (sender retransmits, receiver identifies duplicate packet via sequence numbers and resends ACK), and delayed acknowledgments (sequence numbers on ACKs prevent sender confusion about which packet is being acknowledged). The total time for one packet transmission and ACK receipt is the round-trip time (RTT), approximately Transmission Delay + 2 * Propagation Delay (ignoring small ACK transmission delay, queuing, and processing delays). Efficiency is calculated as (Useful Time / Total Time) or Transmission Delay / RTT, often simplified to 1 / (1 + 2a), where 'a' is Propagation Delay / Transmission Delay. Throughput is defined as (Frame Size / RTT). Efficiency is maximized with shorter link lengths, lower transmission rates, and larger packet sizes.
Sliding Window Protocols enhance efficiency by allowing the sender to transmit multiple packets (defined by the sender's window size) without waiting for an acknowledgment for each. In Go-Back-N (GBN) ARQ, the sender's window size is N, while the receiver's window size is always 1. This means the receiver must receive packets strictly in order; if any packet is lost, it discards all subsequent out-of-order packets. The sender maintains a timer only for the first unacknowledged packet in its window. If a timeout occurs, the sender retransmits the lost packet and all subsequent packets in its current window. GBN typically uses cumulative acknowledgments. In Selective Repeat (SR) ARQ, both the sender and receiver have a window size of N. The receiver can accept and buffer out-of-order packets while waiting for missing ones. Each transmitted packet usually has its own timer, and only selected lost packets are retransmitted. SR is more efficient than GBN in terms of retransmissions but requires more complex buffering and sorting logic at the receiver. For reliability, sequence numbers are crucial. The total available sequence numbers (2^k for k-bit sequence numbers) must be greater than the sum of sender and receiver window sizes to prevent ambiguity over duplicate packets after wrap-around. Efficiency is calculated as (N * Transmission Delay) / RTT, where N is the sender's window size. Both GBN and SR significantly improve network utilization over Stop-and-Wait by keeping the sender busy.
The IPv4 header contains crucial information for routing and packet handling. It begins with the 'Version' field (4 bits), indicating whether it's IPv4 (0100) or IPv6 (0110). The 'Header Length' (4 bits) specifies the size of the IP header in 32-bit words. Since the minimum header size is 20 bytes (5 words) and maximum is 60 bytes (15 words), this 4-bit field reports a value between 5 and 15, with a scaling factor of 4 to convert to bytes. The 'Services' field (8 bits) includes 'Precedence/Priority' bits (first 3 bits) to prioritize packets, especially during congestion. The next 4 bits represent 'Type of Service' (DTRC: Minimum Delay, Maximum Throughput, High Reliability, Minimum Cost), where only one service can be prioritized at a time. The last bit is unused. The 'Total Length' field (16 bits) specifies the entire datagram size (header + data) in bytes, allowing for a maximum of 65,535 bytes per datagram. Assuming a minimum 20-byte IP header, the maximum data size at the network layer is 65,515 bytes.
The 'Identification' field (16 bits) uniquely identifies all fragments belonging to the same original datagram. When a large datagram is fragmented due to a smaller Maximum Transfer Unit (MTU) on a link, each fragment carries the same identification number to allow reassembly at the destination. The 'Flags' field (3 bits) has specific controls: the first bit is unused. The 'Don't Fragment' (DF) flag (second bit) indicates whether the datagram can be fragmented (0) or not (1). If DF is set to 1 and the datagram needs fragmentation, the router discards it and sends an ICMP message back to the source. The 'More Fragments' (MF) flag (third bit) indicates if more fragments are following (1) or if it's the last fragment (0). The 'Fragmentation Offset' (13 bits) specifies the position of a fragment's data payload within the original datagram, relative to the beginning of the original data. It's measured in 8-byte blocks (a scaling factor of 8). For example, the first fragment's offset is 0, the second fragment's offset would be 100/8=12.5 if 100 bytes of data were transferred in the first fragment, and so on. The maximum offset value is 8191.
The 'Time to Live' (TTL) field (8 bits) prevents datagrams from looping infinitely in a network. The sender sets an initial TTL value, which is decremented by one each time a datagram passes through a network layer device (like a router). If TTL reaches zero before reaching the destination, the datagram is discarded, and an ICMP 'Time Exceeded' message is sent back to the source. The 'Protocol' field (8 bits) identifies the higher-layer protocol (e.g., TCP (6), UDP (17), ICMP (1), IGMP (2)) that encapsulated the data in the IP datagram. This helps routers prioritize discarding less critical packets during congestion (e.g., ICMP before TCP). The 'Header Checksum' (16 bits) is used for error detection specifically for the IP header. It is recomputed and verified at every hop because fields like TTL change. 'Source IP Address' and 'Destination IP Address' (both 32 bits) remain constant from source to destination. Lastly, the 'Options' field (up to 40 bytes) provides additional functionalities like 'Strict Source Routing' (exact path specified), 'Loose Source Routing' (intermediate routers specified, but flexibility between them), 'Record Route' (routers record their IP in the header), 'Timestamp' (routers record arrival/departure times), and 'Padding' (aligning header length to a 32-bit boundary).
Transport layer protocols (TCP and UDP) facilitate 'process-to-process' or 'end-to-end' communication, ensuring messages reach the correct application on the destination host, using port numbers for identification. This is distinct from the network layer's 'host-to-host' communication. Protocols are categorized as 'connectionless' (frames are independent, sent without logical connection) or 'connection-oriented' (a logical connection is established in a setup phase, data transferred, and then terminated in a tear down phase). Connection-oriented protocols, like TCP (Transmission Control Protocol), are reliable and ensure in-order delivery. Connectionless protocols, like UDP (User Datagram Protocol), are unreliable but fast, with less overhead, treating each segment independently. Reliability (flow control, error control, congestion control) is a key responsibility of the transport layer.
A computer network is defined as a telecommunication framework enabling digital devices (nodes) to interact, either wired or wirelessly, to share hardware or software resources. Key components of data communication include sender, receiver, message, transmission medium, and protocols (rules for synchronization). Effectiveness is measured by delivery to the correct destination, data accuracy (without unintentional errors), timeliness, and minimal jitter (uneven delay). Transmission modes are categorized into simplex (unidirectional, like TV), half-duplex (bidirectional but not simultaneous, like a walkie-talkie), and full-duplex (simultaneous bidirectional, like a telephone call). Network criteria also consider reliability (fewer failures and quicker resolution), performance (transit time, response time, number of users), and security (confidentiality, integrity, availability). Different connection types (point-to-point and multipoint) and topologies (bus, ring, star, tree, mesh, hybrid) are introduced. Mesh topology, as a complete graph, offers low traffic issues, fault tolerance, and easy fault identification, but at higher cost and installation complexity.
The OSI model serves as a conceptual framework for interoperable network architecture, providing a layered approach to communication irrespective of underlying systems. Each layer communicates with its peer layer in another system. The seven layers are Application, Presentation, Session, Transport, Network, Data Link, and Physical. The course plans to first cover the functionalities of these layers and then their coordination. The importance of binary numbers for IPv4 addressing is highlighted, demonstrating binary-to-decimal conversion, powers of two, and quick calculation tricks like 2^n-1 for consecutive ones. This foundation is crucial for understanding IP addressing.
IPv4 addresses are 32-bit logical addresses, typically represented as four 8-bit octets separated by dots. This allows for 2^32 unique IP addresses. Initially, IP addresses were divided into Network ID (NID) and Host ID (HID). An early fixed division (8-bit NID, 24-bit HID) resulted in 256 networks, each supporting 16 million hosts, leading to significant IP address wastage for smaller organizations. To address this, classful addressing was introduced, categorizing networks into classes A, B, C, D, and E with varying NID and HID bit allocations. Class A (8-bit NID, 24-bit HID) serves large organizations, Class B (16-bit NID, 16-bit HID) for medium-sized ones, and Class C (24-bit NID, 8-bit HID) for small ones. Classes D and E are reserved for multicasting and experimental purposes, respectively, without a NID/HID distinction. This class-based system, while improving on fixed-length addressing, still led to wastage as organizations often needed an intermediate number of hosts, forcing them to purchase larger blocks than necessary.
IPv4 address space is hierarchically divided into classes A, B, C, D, and E based on fixed initial bits. Class A (starts with 0) occupies 50% of the address space, Class B (starts with 10) 25%, Class C (starts with 110) 12.5%, and Classes D (starts with 1110) and E (starts with 1111) each 6.25%. Address representation can be binary, decimal (dot-decimal notation), or hexadecimal. Within Class A, 126 networks are available (2^7 - 2), as 0.0.0.0 (default route/DHCP client) and 127.x.x.x (loopback/self-connectivity testing) are reserved. For each network, 2^24 - 2 unique host IPs are available, as all zeros (network ID) and all ones (broadcast address) in the Host ID portion are reserved. Loopback testing allows a device to send a message to itself to verify its own network stack, using the 127.x.x.x address range as the destination IP. This address cannot be used as a source IP. Similar rules apply to Classes B and C regarding reserved NID and HID values, but without fixed overall zero/one NID exclusions due to the class-defining prefix bits.
For Class B, the first two bits are fixed as '10', leaving 14 bits for the Network ID (2^14 networks) and 16 bits for the Host ID (2^16 - 2 hosts per network). Unlike Class A, no NID is entirely reserved because the '10' prefix prevents it from being all zeros. For Class C, '110' prefixes the NID, providing 2^21 networks and 2^8 - 2 hosts per network. Classes D and E do not have separate NID/HID concepts; they are identified by their '1110' and '1111' prefixes respectively, and addresses are reserved for multicasting (D) and research (E). The first octet's value directly indicates the IP address class: Class A (1-126), Class B (128-191), Class C (192-223), Class D (224-239), and Class E (240-255). Special IPs include 255.255.255.255 for limited broadcast (within the same network), and a network ID with all ones in the host portion represents a direct broadcast address (to all hosts in a specific network). Both cannot be source IPs and directly broadcast IPs cannot be assigned to hosts.
Subnetting involves dividing a large network into smaller subnets. This improves network management, administration, and security by isolating segments. However, it increases management complexity (more steps to identify a host), wastes more IP addresses (each subnet reserves addresses for its ID and broadcast), and raises costs due to necessary intermediary devices (routers, switches) and expert administrators. Subnets are created by 'borrowing' bits from the Host ID part of an IP address. The number of borrowed bits determines the number of subnets (2^n subnets for n borrowed bits). For Class C network 200.200.200.0, borrowing two bits from the 8-bit Host ID creates four subnets, each with 2^6-2=62 usable hosts. The borrowed bits become the Subnet ID (SID), allowing for precise addressing of hosts within specific subnets. Subnet IDs start from 0, while host IDs start from 1 (as all zeros and all ones in the host portion are reserved). The subnet mask aids in identifying the NID and SID portions of an IP address; for Class C with two borrowed bits, the subnet mask would be 255.255.255.192.
The TCP header contains several key fields. The first row includes the 'Source Port Address' and 'Destination Port Address' (16 bits each), identifying the communicating processes. The 'Sequence Number' (32 bits) uniquely identifies each data byte in a TCP connection, starting from a random initial value and allowing wraparound (reusing numbers after reaching 2^32 - 1). This ensures ordered delivery and aids reliability, with the wraparound time (2^32 / bandwidth) being critical to avoid confusion with old segments. The 'Acknowledgement Number' (32 bits) indicates the sequence number of the next byte the receiver expects, enabling cumulative acknowledgments (piggybacking ACK with data). The 'Header Length' (4 bits) functions identically to the IP header's version, scaling from 5-15 to 20-60 bytes. 'Checksum' (16 bits) provides error control for the TCP segment (data + header) and an IP pseudo-header. The 'Window Size' (16 bits), also known as advertisement window, informs the sender of the receiver's available buffer space, preventing overflow. Additionally, six control flags (URG, ACK, PSH, RST, SYN, FIN) manage connection state: URG (Urgent) indicates urgent data, ACK validates the Acknowledgment Number, PSH (Push) requests immediate data delivery, RST (Reset) aborts a connection, SYN (Synchronize) initiates a connection, and FIN (Finish) terminates a connection.
The TCP's three-way handshake establishes a connection: Client sends a SYN packet (SYN flag set, random sequence number X). Server responds with a SYN-ACK packet (SYN and ACK flags set, random sequence number Y, acknowledgment number X+1). Client replies with an ACK packet (ACK flag set, sequence number X+1, acknowledgment number Y+1). This ensures both sides are ready and synchronize sequence numbers for bidirectional communication. Connection termination uses a similar FIN (Finish) handshake. TCP congestion control prevents network collapse due to excessive traffic. The sender's effective window size is the minimum of the 'Receiver Window' (advertised by receiver for flow control) and the 'Congestion Window' (estimated by sender to avoid network congestion). TCP employs a multi-phase policy: 'Slow Start' (exponential increase of congestion window from 1 MSS), 'Congestion Avoidance' (additive increase after reaching a threshold, typically half of receiver's capacity), and 'Congestion Detection' (rapidly reducing congestion window upon packet loss). Timers like the 'Time-Wait Timer' (2 * maximum segment lifetime) and 'Keep-Alive Timer' (detects idle connections) prevent issues like late packets or deadlocks.
UDP (User Datagram Protocol) is a connectionless and unreliable transport protocol. It offers simplicity and low overhead due to the lack of pre-established logical connections, sequence numbers, flow control, error control, or congestion control mechanisms. UDP treats each segment as an independent packet, allowing for out-of-order delivery. Its header is a fixed 8 bytes, containing source port, destination port, total length, and an optional checksum. UDP's benefits include speed, efficiency (due to low overhead), and suitability for real-time applications (e.g., streaming) where minor data loss is acceptable, unlike TCP's strict reliability. Key differences between TCP and UDP: TCP is connection-oriented, reliable, has a dynamic header (20-60 bytes), employs flow/error/congestion control, uses sequence and acknowledgment numbers, and is slower due to overhead. UDP is connectionless, unreliable, has a fixed 8-byte header, lacks inherent controls (flow, error, congestion), is faster, and has lower overhead. Common TCP-based applications include HTTP, FTP, SMTP; UDP applications include DNS, SNMP, TFTP, and multimedia streaming. Both protocols use socket addresses (IP address + port number) for process-to-process communication.
The Media Access Control (MAC) layer is responsible for controlling access to a shared communication medium. Multiple access protocols are categorized into Random Access, Controlled Access, and Channelization. Random Access Protocols (also called contention methods) allow any station to send data at any time, leading to potential collisions. Aloha, designed for wireless LANs, is a prime example. In Pure Aloha, stations transmit whenever they have data. If an acknowledgment (ACK) isn't received within a timeout period (typically 2 * propagation delay, or 2PD), the frame is assumed lost or corrupted due to collision, and retransmission occurs after a random 'back-off' time to reduce further collisions. The back-off time uses a random number K (0 to 2^N-1, where N is the collision number) multiplied by a slot time. Pure Aloha has a vulnerable time of 2 * Transmission Delay (TD) and a maximum theoretical throughput of 18.4% (achieved when the generation rate G is 0.5 frames per TD). Slotted Aloha divides time into fixed slots, requiring stations to transmit only at the beginning of a slot. This halves the vulnerable time to 1 * TD and doubles the maximum theoretical throughput to 36.8% (achieved when G is 1 frame per TD). Both Aloha variants suffer from the 'capture effect,' where a station winning an early collision is more likely to win subsequent ones, reducing fairness.
CSMA (Carrier Sense Multiple Access) mitigates collisions by requiring stations to 'sense' the medium for activity before transmitting. However, due to propagation delay, a station might sense the channel idle while another transmission is underway, still leading to collisions. The vulnerable time in CSMA is the propagation delay. Different CSMA persistence methods dictate behavior if the channel is busy: '1-Persistent' continuously senses and transmits immediately when idle (high collision risk, used in Ethernet LAN). 'Non-Persistent' senses, and if busy, waits a random time before sensing again (lower collision risk but reduced efficiency as channel may sit idle). 'P-Persistent' (for slotted channels) senses, and if idle, transmits with probability P or waits for the next slot with probability 1-P. CSMA/CD (Carrier Sense Multiple Access with Collision Detection) builds on CSMA by allowing stations to detect collisions while transmitting. If a collision is detected early, the station immediately stops transmitting, saving bandwidth. This requires two ports (one for sending, one for detecting). Upon detection, a 'jam signal' is sent to notify all other stations. A crucial concept is the 'minimum frame size,' which must be large enough to ensure collision detection before the entire frame is transmitted fully (Transmission Delay > 2 * Propagation Delay). CSMA/CD's exponential back-off algorithm dynamically increases the retransmission delay window, reducing collision probability over time, but it can lead to the 'capture effect' where a repeatedly successful station gains an advantage.
Controlled Access Protocols eliminate collisions by regulating which station can transmit. These methods are collision-free. 'Polling' uses a primary station to control secondary stations. The primary polls secondary stations to see who wants to transmit. Data is relayed through the primary, preventing direct secondary-to-secondary communication (common in star topology). This ensures no collisions but has low bandwidth utilization due to excessive polling and acknowledgements. 'Reservation' divides time into intervals, where stations reserve mini-slots in a reservation frame before transmitting data. This allows for scheduled, collision-free transmission. 'Token Passing' logically connects stations in a ring. A special 'token' grants transmission rights; only the station holding the token can transmit. This is effective for broadcast-like scenarios and avoids collisions. Channelization Protocols (FDMA, TDMA, CDMA) allocate dedicated 'channels' (frequency, time, code) to stations, eliminating contention by providing exclusive access. TDMA (Time Division Multiple Access) allocates time slots in a round-robin fashion; however, if a station has no data in its slot, the slot is wasted, reducing efficiency. CDMA (Code Division Multiple Access) and FDMA (Frequency Division Multiple Access) allocate unique codes or frequency bands, respectively, to stations, allowing simultaneous transmission without interference.
Routing aims to efficiently direct data packets across networks. Flooding, the opposite of routing, sends packets along all outgoing links, guaranteeing the shortest path (first packet to arrive) and high reliability, but causing immense traffic and duplicate packets. Routing reduces traffic and duplicates but requires complex algorithms and doesn't guarantee the shortest path or high reliability in dynamic topologies. Dynamic routing algorithms adapt to network changes. Distance Vector Routing (DVR) (e.g., RIP - Routing Information Protocol) builds routing tables based on local knowledge, exchanging 'distance vectors' (cost to reach destinations) with immediate neighbors. Each router updates its table using algorithms like Bellman-Ford, aiming for the minimum cost path. DVR suffers from slow 'convergence' (time to adapt to network changes) and the 'count-to-infinity' problem. Link State Routing (LSR) (e.g., OSPF - Open Shortest Path First) addresses DVR's limitations. Routers exchange 'link state packets' (LSPs) containing information about their directly connected links and their costs. LSPs are 'flooded' across the entire network, building a global topological map at each router. Each router then independently uses Dijkstra's algorithm to compute the shortest path to all destinations. LSR offers faster convergence and a global view of the network but requires more bandwidth for flooding and more computation. In switching, 'Circuit Switching' (physical layer) establishes a dedicated physical path for the entire communication duration (setup, data transfer, tear down phases), reserving resources, offering no delays, and no headers. 'Packet Switching' (network layer) breaks data into independent packets that use shared resources and can follow multiple paths, requiring headers for addressing and reassembly at the destination. Packet switching is more flexible, fault-tolerant (re-routing), and efficient for small messages; circuit switching is efficient for large, continuous data flows.
The application layer provides services to users, encompassing protocols like SMTP, DNS, FTP, and HTTP. SMTP (Simple Mail Transfer Protocol) is for email transmission, pushing mail from sender to sender's mail server, and then to the receiver's mail server (port 25, TCP). It is text-based (7-bit ASCII) and stateless, though it uses a persistent TCP connection. MIME (Multi-purpose Internet Mail Extension) supplements SMTP by converting non-ASCII data (multimedia, non-English text) to ASCII for transmission. POP3 (Post Office Protocol version 3) and IMAP4 (Internet Message Access Protocol version 4) are pull protocols used by receivers to download mail from their mail server. POP3 (port 110, TCP) is simpler, deleting mail after download (delete mode) or leaving a copy (keep mode), but doesn't allow server-side organization. IMAP4 (port 143, TCP) is more advanced, supporting email organization, partial downloads, and content searching on the server. DNS (Domain Name System) translates human-readable domain names (e.g., google.com) into IP addresses (port 53). It uses a hierarchical structure (root, top-level domain, authoritative servers) and operates through either iterative queries (each server replies with the next server's address) or recursive queries (each server forwards the query to the next until the answer is found). DNS primarily uses UDP for efficiency but switches to TCP for large query sizes (>512 bytes). FTP (File Transfer Protocol) transfers files between computers (ports 20 and 21, TCP). It's an 'out-of-band' protocol, using separate connections for data (port 20) and control (port 21); the control connection persists, while data connections are opened/closed per file. HTTP (Hypertext Transfer Protocol) accesses data on the World Wide Web (port 80, TCP). It is stateless and can be non-persistent (HTTP 1.0, new TCP connection per request/response) or persistent (HTTP 1.1, single TCP connection for multiple requests). Finally, IP support protocols include ARP (Address Resolution Protocol), which broadcasts an IP address to resolve its corresponding MAC address (reply is unicast), and ICMP (Internet Control Message Protocol), used for error reporting and network diagnostics (e.g., TTL expiration, destination unreachable). ICMP packets are not generated for other ICMP packets to prevent congestion.