Computer Networking: Principles, Protocols and Practice PDF Download – Bonaventure (3rd Edition) BSCS

BSCS and BSIT students can download the complete Computer Networks textbook “Computer Networking: Principles, Protocols and Practice” by Olivier Bonaventure of UCLouvain. The book is free from its official source and covers the full Computer Networks course taught at Pakistani universities.

Its structure is what makes it unusual. Part 1 teaches the principles first — reliable transfer, forwarding, addressing, resource sharing — without naming a single real protocol, so you learn why networks are built the way they are. Part 2 then applies those principles to the actual Internet protocols: DNS, email, HTTP, TLS, UDP, TCP, IPv6, OSPF, BGP, Ethernet and WiFi. Part 3 is sixteen sets of exercises and hands-on labs. It is also one of the few textbooks that teaches the network layer as IPv6 first rather than as an afterthought, which matches where networks are actually going.

Book Overview

Course	Computer Networks / Data Communication
Degree Programs	BSCS, BSIT, BSSE
Level	University / Upper-level undergraduate
Edition	Third edition (2021)
Author	Olivier Bonaventure, with contributions from the UCLouvain networking group
Publisher	Université catholique de Louvain (UCLouvain), Belgium
Language	English
Structure	24 chapters in three parts, plus 16 sets of exercises and labs
License	CC BY 3.0 — Model: Link-only
Format	Free PDF, ePub, and an interactive online edition with in-page exercises

Chapter List

Chapter 1: Connecting two hosts

Part 1: Principles · Difficulty: Medium · Key topics: physical layer, framing, bit stuffing, error detection, alternating bit protocol, go-back-n, selective repeat

The book starts with the smallest possible network: two hosts joined by one wire. It surveys the physical media used to carry bits — twisted pair, coaxial cable, optical fibre, radio — then moves to the datalink layer, where the unit of information becomes the frame. The framing problem is stated precisely: how does a sender mark frame boundaries in a continuous bit stream? Idle gaps are rejected as a solution because some physical layers cannot go idle and because gaps waste bandwidth, which leads to bit stuffing and character stuffing instead. The chapter then builds a reliable protocol step by step, first assuming a perfect physical layer and then adding recovery from corrupted and lost frames, ending with pipelining through go-back-n and selective repeat.

Key Points:

• The physical layer carries bits; the datalink layer groups them into frames.
• Framing means marking where each frame begins and ends inside a continuous bit stream.
• Idle periods are not an acceptable framing method: some physical layers must always transmit, and gaps reduce the achievable bit rate.
• Two error types must be handled at this layer: frames corrupted by transmission errors, and frames lost or duplicated.
• The alternating bit protocol is correct but slow because the sender waits for an acknowledgement after every frame.
• Pipelining lets a sender transmit W unacknowledged frames before waiting; W is the sending window.
• Go-back-n retransmits every frame from the lost one onward; selective repeat retransmits only the missing frame.

Memory Tip: Fix the two pipelined protocols by what they throw away. Go-back-n throws away everything after the gap and resends it all; selective repeat keeps the good frames and resends only the hole. Simpler receiver versus less wasted bandwidth — that trade-off is the whole comparison.

Common Mistake: Treating the alternating bit protocol as merely a teaching toy. It is the ancestor of TCP’s sequence numbers and acknowledgements, and the same reasoning about timeouts and duplicates reappears in Chapter 19.

Important Questions:

• What is the framing problem? How a sender encodes frames so the receiver can extract them from the continuous bit stream delivered by the physical layer, given that the physical layer is imperfect.
• What is the difference between go-back-n and selective repeat? After a loss, go-back-n retransmits that frame and every frame sent after it; selective repeat retransmits only the frames actually missing, which saves bandwidth but needs a more complex receiver.

Chapter 2: Building a network

Part 1: Principles · Difficulty: Hard · Key topics: network layer, datagram organization, forwarding tables, virtual circuits, flat vs hierarchical addressing, fragmentation, control plane, distance vector, link state

Connecting two hosts is not a network, so this chapter adds the network layer and the router. Two organizations are compared throughout. The datagram organization is modelled on the postal service: each packet carries the source and destination addresses, and each router consults a forwarding table to choose an outgoing interface. The virtual circuit organization is modelled on the telephone network: a channel is set up first, and packets then carry a short label rather than a full address. The chapter shows how forwarding tables are built — in trees, by learning from packets, and in general graphs by distance vector or link state routing — and why flat addressing does not scale, which motivates hierarchical addresses and aggregation. It closes on heterogeneous datalink layers, MTUs and fragmentation, and separates the data plane from the control plane.

Key Points:

• The unit of information in the network layer is the packet; routers are the intermediate systems that forward it.
• In the datagram organization every packet carries full source and destination addresses; in virtual circuits a channel is established first.
• The forwarding table maps a destination to an outgoing interface; the routing table is what the control plane maintains.
• The data plane forwards packets; the control plane computes the tables it forwards with.
• Flat addressing gives every host a unique unrelated address and does not scale; hierarchical addressing allows aggregation.
• Different datalink layers have different maximum frame sizes, so the network layer needs fragmentation or path MTU discovery.
• Distance vector routers exchange distances to destinations; link state routers flood the topology and each computes shortest paths itself.

Memory Tip: Anchor the two organizations to their real-world models: datagram is the postal service (every letter carries the full address, each office decides the next hop independently), virtual circuit is the telephone network (set up the call first, then just talk). Nearly every difference in the exam follows from that one image.

Common Mistake: Mixing up the forwarding table and the routing table. Forwarding is the per-packet lookup in the data plane; routing is the protocol work in the control plane that keeps that table correct.

Important Questions:

• What is the difference between the datagram and virtual circuit organizations? In the datagram organization each packet carries the destination address and is forwarded independently; in the virtual circuit organization a path is established before data flows and packets carry a short circuit label.
• Why is hierarchical addressing used instead of flat addressing? Because flat addresses cannot be aggregated, so every router would need one forwarding entry per host; hierarchical addresses let one entry cover a whole block.

Chapter 3: Applications and the transport layer

Part 1: Principles · Difficulty: Medium · Key topics: client-server model, peer-to-peer, connectionless vs connection-oriented service, service primitives, segments, multiplexing

This chapter introduces the two ends of the stack that the rest of the book works between. It first describes how networked applications are organized: the client-server model, which is asymmetric because clients send requests and servers respond, and the peer-to-peer model, in which every host acts as both. It then defines the transport layer as the layer that improves the network layer service enough for applications to use it. The network layer’s limitations are listed explicitly — it can corrupt data, lose data, deliver out of order, duplicate data, and it caps the size of what you can send — and each transport mechanism in later chapters exists to fix one of them. The two transport services are then defined: the connectionless service, which exchanges independent messages, and the connection-oriented byte-stream service.

Key Points:

• In the client-server model the interaction is asymmetric: clients request, servers respond.
• In the peer-to-peer model every host can act as both client and server.
• The transport layer exists to improve the network layer service to something applications can use.
• The network layer may corrupt, lose, reorder or duplicate data, and limits the maximum size of what can be sent.
• The connectionless transport service exchanges independent messages; the connection-oriented service delivers an ordered byte stream.
• Multiplexing lets several applications on one host share the same network layer service.

Memory Tip: Learn the five network layer defects as a checklist — corrupt, lose, reorder, duplicate, size limit. Every transport mechanism you meet later (checksums, sequence numbers, acknowledgements, segmentation) is the fix for exactly one item on that list.

Common Mistake: Assuming peer-to-peer means “no servers anywhere”. The model describes the roles hosts play in the exchange, and most real peer-to-peer systems still use servers for bootstrapping and lookup.

Important Questions:

• What is the difference between the client-server and peer-to-peer models? Client-server is asymmetric — one side only requests and the other only serves; in peer-to-peer each host acts as both client and server.
• Why is a transport layer needed above the network layer? Because the network layer service is unreliable and unstructured: it can corrupt, lose, reorder and duplicate data and limits message size, so the transport layer adds the guarantees applications need.

Chapter 4: Naming and addressing

Part 1: Principles · Difficulty: Easy · Key topics: names vs addresses, port numbers, directory service, flat vs hierarchical name spaces, name resolution

A short but load-bearing chapter. Addresses are fixed-size bit strings chosen for machines: a network layer address identifies a host, and port numbers identify which application on that host should receive the data, so the transport layer can multiplex several processes over one address. Names are chosen for humans. Because the two are different, every network needs a directory service to map one to the other, and the chapter analyses what such a service must provide and how a flat name space differs from a hierarchical one. This is the chapter that makes DNS, in Chapter 9, feel inevitable rather than arbitrary.

Key Points:

• A network layer address identifies a host; a port number identifies an application process on that host.
• Names are for humans; addresses are fixed-size bit strings for machines.
• A directory service maps names to addresses, and every network needs one.
• Multiplexing is what allows several transport protocols and several applications to share one network layer.
• A flat name space is simple but cannot be delegated; a hierarchical name space can be split among many administrators.

Memory Tip: The full identity of one end of a connection is host address plus port number plus protocol. Whenever a question about multiplexing or sockets confuses you, write that triple down first — the answer is almost always which part of it distinguishes the two flows.

Common Mistake: Reading this chapter as “the DNS chapter”. It defines the problem in the abstract; DNS is only one particular solution to it, and the exam often asks about the distinction.

Important Questions:

• What is the difference between a name and an address? A name is a human-friendly identifier with no structural meaning to the network; an address is a fixed-size bit string that the network uses to locate a host, and a directory service maps between them.
• Why are port numbers needed when a host already has an address? Because several applications run on one host, and the port number tells the transport layer which process a segment belongs to.

Chapter 5: Sharing resources

Part 1: Principles · Difficulty: Hard · Key topics: bandwidth sharing, congestion, fairness, ALOHA, CSMA, CSMA/CD, CSMA/CA, token passing, AIMD, window-based congestion control

The longest chapter in Part 1, and the one with the most exam material. It identifies bandwidth as the resource networks must share and splits the problem in two. The first half handles hosts sharing one physical medium and works through the Medium Access Control algorithms in historical order: static allocation, then ALOHA and slotted ALOHA from the University of Hawaii, then CSMA which listens before transmitting, then CSMA/CD which also listens while transmitting and aborts on collision, then CSMA/CA which adds inter-frame spacing and acknowledgements for wireless, and finally the deterministic token-based schemes. The second half handles congestion, where too much traffic meets a slow link inside the network. It defines fairness, explains why routers must signal congestion, and derives Additive Increase Multiplicative Decrease and how a window-based protocol implements it — which is exactly what TCP does in Chapter 20.

Key Points:

• MAC algorithms split into optimistic (ALOHA, CSMA family) and deterministic (token-based) families.
• ALOHA transmits immediately and retries after a collision; slotted ALOHA doubles throughput by aligning transmissions to time slots.
• CSMA listens before transmitting; CSMA/CD also listens while transmitting and aborts as soon as it detects a collision.
• CSMA/CA is used by WiFi because a radio cannot listen while transmitting, so collisions cannot be detected, only avoided.
• Congestion is different from collision: it happens inside the network when arriving traffic exceeds an outgoing link’s capacity.
• AIMD increases the rate additively while the network is fine and cuts it multiplicatively on congestion, which converges to fairness.
• Adjusting a sending window is the practical way to implement AIMD, because controlling a rate directly needs fine-grained timers.

Memory Tip: Keep CD and CA apart by the medium. On a cable a station can listen while it transmits, so it can detect a collision — CSMA/CD, used by Ethernet. On radio it cannot hear anything while transmitting, so it can only avoid collisions in advance — CSMA/CA, used by WiFi. One physical fact explains both names.

Common Mistake: Using “collision” and “congestion” as synonyms. A collision is two stations transmitting on the same medium at the same instant; congestion is a router receiving more traffic than its outgoing link can carry. They happen at different places and have completely different solutions.

Important Questions:

• Why does WiFi use CSMA/CA instead of CSMA/CD? A wireless station cannot listen to the channel while it is transmitting, so it cannot detect a collision; CSMA/CA therefore avoids collisions in advance using inter-frame spacing and acknowledgements.
• What is AIMD? Additive Increase Multiplicative Decrease: a sender raises its window by a fixed amount while no congestion is detected and cuts it by a multiplicative factor when congestion is detected, which drives competing flows toward a fair share.

Chapter 6: The reference models

Part 1: Principles · Difficulty: Easy · Key topics: five-layer reference model, OSI model, TCP/IP model, encapsulation, service primitives

Having built each layer from its problem, the book now names the stack. It presents a five-layer reference model — physical, datalink, network, transport, application — and states plainly that this is a simplified version of the OSI model, which was the most influential of the 1970s proposals and the basis of ISO’s standardization work. Each of the five layers is described in terms of the service it provides to the layer above and the service it consumes from the layer below. The chapter then compares this model with the seven-layer OSI model and with the TCP/IP reference model, explaining where they agree and where they do not. This is the short chapter that makes exam questions about “which layer does X belong to” answerable.

Key Points:

• The book’s model has five layers: physical, datalink, network, transport, application.
• OSI has seven layers — it adds the session and presentation layers between transport and application.
• The TCP/IP reference model has four layers and no session or presentation layer.
• Each layer provides a service to the layer above and uses the service of the layer below.
• Encapsulation: each layer adds its own header, so a segment sits inside a packet, which sits inside a frame.
• The unit of data has a different name per layer: bit, frame, packet, segment, message.

Memory Tip: Memorise the data-unit names alongside the layers — bit, frame, packet, segment, message, bottom to top. Half the marks in reference-model questions come from naming the right unit at the right layer, and the sequence is easier to hold than the layer names alone.

Common Mistake: Answering every layering question with the seven-layer OSI model. This book uses a five-layer model throughout, and its chapter numbering follows that; check which model the question is set in.

Important Questions:

• What are the five layers used in this book? Physical, datalink, network, transport and application.
• How does the OSI model differ from the TCP/IP model? OSI defines seven layers, adding session and presentation layers above transport; the TCP/IP model has four and folds those functions into the application layer.

Chapter 7: Network security

Part 1: Principles · Difficulty: Medium · Key topics: confidentiality, integrity, authentication, symmetric and public key cryptography, hash functions, digital signatures, key distribution

Security is treated as a principle rather than as a bolt-on, because Part 2 spends three whole chapters (TLS, ssh and DNSSEC) applying it. The chapter starts from how networks became security-relevant at all: early networks connected trusted researchers, and access control began with usernames and passwords on standalone machines. It then defines the goals — confidentiality, integrity, authentication — and builds the cryptographic toolbox needed to reach them: symmetric ciphers with one shared key, public key cryptography with a key pair, cryptographic hash functions that detect any change, message authentication codes, and digital signatures. Key distribution is treated as the hard problem it is, which sets up why certificates exist in Chapter 15.

Key Points:

• The three goals are confidentiality (nobody else can read it), integrity (nobody changed it) and authentication (it really is who it claims to be).
• Symmetric cryptography uses one shared secret key for both encryption and decryption and is fast.
• Public key cryptography uses a public and a private key; anyone can encrypt to you, only you can decrypt.
• A cryptographic hash is one-way and fixed-length, so any change to the data changes the digest completely.
• A digital signature is made with the sender’s private key and verified with the public key, giving integrity plus authentication.
• Key distribution, not the ciphers, is the hard part — which is why certificates and a trusted authority are needed.

Memory Tip: Keep the two key operations straight with one sentence: encrypt with the receiver’s public key for secrecy, sign with your own private key for proof. Confuse those two and every question in this chapter and in TLS goes wrong.

Common Mistake: Thinking encryption alone gives integrity. An attacker who cannot read a message can still corrupt it, which is why a MAC or signature is needed in addition to the cipher.

Important Questions:

• What is the difference between symmetric and public key cryptography? Symmetric cryptography uses one shared secret key for both directions; public key cryptography uses a key pair, where the public key encrypts or verifies and the private key decrypts or signs.
• Why is key distribution the hard problem in network security? Because the cryptography only protects you if the other side really holds the key you think it does, and establishing that over an untrusted network requires certificates and a trusted third party.

Chapter 8: The application layer

Part 2: Protocols · Difficulty: Easy · Key topics: connectionless and byte-stream transport services, port numbers, sockets, the socket API

Part 2 opens by connecting the abstract transport services of Part 1 to the API a programmer actually uses. The two services are restated concretely: the connectionless service, provided on the Internet by UDP, which exchanges independent messages, is unreliable but does detect transmission errors so corrupted data is never delivered; and the connection-oriented byte-stream service, provided by TCP. An application is then identified by the host it runs on plus the port number it listens on. The chapter introduces the socket interface that both services are used through, which is what makes Part 3’s socket labs possible.

Key Points:

• The connectionless service on the Internet is provided by UDP; the byte-stream service is provided by TCP.
• The connectionless service is unreliable but still detects transmission errors, so corrupted data is discarded rather than delivered.
• An application is identified by its host plus the port number it listens on.
• The socket API is the common interface to both transport services.
• A server socket listens; a client socket connects.

Practice Tip: Write the smallest possible UDP client and TCP client in the same language, sending the same string. Seeing that one needs a connect and the other does not is the fastest way to internalise the difference between the two transport services.

Common Mistake: Assuming UDP has no error checking at all. It does not guarantee delivery, but its checksum means a corrupted datagram is dropped rather than handed to your application.

Important Questions:

• How is a networked application identified? By the host on which it runs and the port number on which it listens, together with the transport protocol in use.
• Is the connectionless transport service completely unreliable? It does not guarantee delivery or ordering, but it does detect transmission errors, so a corrupted message is discarded instead of being delivered to the application.

Chapter 9: The Domain Name System

Part 2: Protocols · Difficulty: Medium · Key topics: DNS message format, sections, resource records, resolvers, caching, DNS over UDP and TCP

Chapter 4 defined the directory service problem; this chapter is the Internet’s answer to it. The DNS protocol runs over both the datagram and the byte-stream service: UDP is used for short queries and responses, and TCP when a longer response is expected. A DNS message has five sections, of which the first three are mandatory: a Header describing the message type and the contents of the other sections, a Question section carrying the query sent to the nameserver or resolver, and an Answer section carrying the response. The remaining two are optional. The chapter covers resource record types, how resolvers walk the hierarchy from the root downward, and why caching is essential to keeping the root servers usable.

Key Points:

• A DNS message has five sections; the Header, Question and Answer sections are mandatory.
• DNS uses UDP for short exchanges and TCP when the response is expected to be long.
• The Header states the message type and describes what the other sections contain.
• Resolvers cache answers, which is what keeps load off the root and top-level servers.
• Every cached record carries a TTL that says how long it may be reused.
• The name space is hierarchical, so authority over a zone can be delegated to its owner.

Practice Tip: Run dig against a domain, then run it again with +trace. Watching the resolver walk from the root to the top-level domain to the authoritative server turns the hierarchy from a diagram into something you have seen happen.

Common Mistake: Saying DNS uses UDP, full stop. It uses UDP for short exchanges and switches to TCP for long responses and zone transfers — and exam questions frequently ask exactly when.

Important Questions:

• Which sections does a DNS message contain? Five sections, of which the Header, the Question and the Answer are mandatory and the last two are optional.
• When does DNS use TCP instead of UDP? When a long response is expected, since UDP is used for short queries and responses.

Chapter 10: Electronic mail

Part 2: Protocols · Difficulty: Medium · Key topics: message format, RFC 822 headers, MIME, SMTP, POP, IMAP, mail user agent vs mail server

The chapter opens with the scenario that organises everything else: Alice writes a message in her client and sends it to her email server, her server extracts Bob’s address and delivers the message to Bob’s server, and Bob later retrieves it with his own client or webmail. From this it identifies the four components of the email system — a message format, protocols to move messages between hosts and servers, the client software, and the servers themselves. Each is then covered: the header-plus-body message format and the MIME extensions that allow non-text and multi-part messages; SMTP, the protocol that pushes mail from client to server and between servers; and POP, the protocol a client uses to pull mail off its own server.

Key Points:

• The email system has four components: a message format, transfer protocols, client software and servers.
• An email message is headers followed by a blank line followed by the body.
• MIME extends the original text-only format to attachments, character sets and multi-part messages.
• SMTP pushes mail: from the client to its server, and from one server to another.
• POP pulls mail: it is used only between a client and its own mail server.
• Delivery is store-and-forward, so a message can sit on an intermediate server before moving on.

Memory Tip: Remember the direction of each protocol as push versus pull. SMTP pushes a message onward toward the recipient; POP and IMAP pull it down from your own server. That single distinction answers most email protocol questions.

Common Mistake: Thinking SMTP delivers mail to the recipient’s computer. SMTP only ever reaches the recipient’s server; the recipient’s machine fetches it separately with POP or IMAP.

Important Questions:

• What are the four components of the email system? A message format, the protocols that move messages between hosts and servers, the client software, and the mail servers.
• What is the difference between SMTP and POP? SMTP is used to send a message onward — client to server and server to server; POP is used by a client to retrieve messages from its own server.

Chapter 11: The HyperText Transfer Protocol

Part 2: Protocols · Difficulty: Medium · Key topics: URIs, request and response format, methods, status codes, headers, persistent connections, cookies

The chapter sets HTTP against what came before it, FTP, which dominated file transfer in the 1990s and offered both authenticated and anonymous modes, and explains why HTTP replaced it for document delivery. It then covers the pieces of the web: the URI that names a document, and the request/response exchange in which a client sends a method and a path with headers, and the server replies with a status code, headers and a body. The methods and the status code families are covered, along with the header mechanisms that matter in practice — content negotiation, conditional requests with If-Modified-Since, persistent connections, and cookies, which add state to a protocol that was designed without any.

Key Points:

• HTTP is a request-response protocol running over TCP; the server listens on port 80 by default.
• A request is a method, a path and headers; a response is a status code, headers and a body.
• Status code families: 1xx informational, 2xx success, 3xx redirection, 4xx client error, 5xx server error.
• HTTP itself is stateless — cookies are what let a server recognise a returning client.
• A persistent connection reuses one TCP connection for several requests, avoiding a new handshake each time.
• The HEAD method and the If-Modified-Since header let a browser check whether its cached copy is still current without downloading the document.

Practice Tip: Fetch a page with curl -v and read the request and response headers it prints. Every header this chapter describes is right there in the output, which makes them much easier to remember than a list.

Common Mistake: Calling HTTP stateless and then explaining sessions as if the protocol tracked them. The protocol carries no state; cookies carry it, and the server holds the rest.

Important Questions:

• What do the HTTP status code families mean? 1xx informational, 2xx success, 3xx redirection, 4xx client error and 5xx server error.
• Why are cookies needed if HTTP is stateless? Because the protocol keeps no memory between requests, so the server sends a cookie that the client returns on later requests to identify itself.

Chapter 12: Making HTTP faster

Part 2: Protocols · Difficulty: Hard · Key topics: caching, proxies, CDNs, persistent connections, pipelining, HTTP/2 multiplexing, header compression, QUIC

The web stopped being static documents: it now delivers streaming music and video, games and productivity applications, all with much tighter performance requirements. This chapter collects a decade of work on meeting them. It starts with tuning the servers — moving from one server holding every document to replicated servers and content delivery networks that place copies near users. It then covers avoiding transmission entirely through caching, with HEAD and If-Modified-Since letting a browser confirm its copy is current. Finally it covers the protocol changes themselves: persistent connections and pipelining in HTTP/1.1, then HTTP/2, which multiplexes many streams over one TCP connection and compresses headers to remove the head-of-line blocking that limited HTTP/1.1.

Key Points:

• The web now carries streaming, games and applications, which have far stricter performance needs than static documents.
• Replication and content delivery networks reduce delay by serving content from near the user.
• The cheapest transfer is the one you avoid: HEAD plus If-Modified-Since confirms a cached copy without re-downloading it.
• HTTP/1.1 added persistent connections and pipelining, but responses still had to come back in order.
• HTTP/2 multiplexes independent streams over a single TCP connection, so one slow response no longer blocks the rest.
• HTTP/2 compresses headers, which matters because requests carry large, highly repetitive header sets.

Memory Tip: The whole chapter answers one question three ways: move the data closer (CDNs), send it less often (caching), or send it better (persistent connections, then multiplexing). Sort any optimisation you meet into one of those three and it stays organised.

Common Mistake: Believing HTTP/2 removed head-of-line blocking completely. It removed it at the HTTP level, but all streams still share one TCP connection, so a lost TCP segment still stalls them all — which is precisely why QUIC was designed.

Important Questions:

• What is the main improvement of HTTP/2 over HTTP/1.1? It multiplexes several independent streams over a single TCP connection and compresses headers, so requests and responses no longer have to be returned in order.
• How does a browser check whether its cached copy is still valid? By sending a conditional request, typically using the HEAD method with an If-Modified-Since header, so the server replies without re-sending the document if it has not changed.

Chapter 13: Remote Procedure Calls

Part 2: Protocols · Difficulty: Medium · Key topics: RPC model, stubs, marshalling, data encoding, binding, failure semantics

Not every application on a network is driven by a human, and this chapter covers applications talking to applications. It starts from the ordinary procedure call: a procedure has a name, a return type and parameters, execution diverts to it, and it returns values — a model designed with a single host in mind. RPC keeps that programming model but puts the network in the middle. The chapter then works through the two problems this creates. First, encoding data: the two hosts may use different processors, operating systems and conventions, so parameters must be marshalled into an agreed representation. Second, reaching the callee: the client must find which host and port implements the procedure. Failure semantics get proper treatment, because a call that vanishes silently is a possibility that local procedure calls never have.

Key Points:

• RPC keeps the familiar procedure call model but runs the procedure on another host.
• Stubs on the client and server hide the network: the caller sees an ordinary function call.
• Marshalling converts parameters into a common representation, because hosts differ in byte order and data layout.
• Binding is how the client finds which host and port implements the procedure.
• Unlike a local call, a remote call can be lost, so the protocol must define what happens on failure and retry.

Memory Tip: Hold on to one distinction: a local procedure call either happens or the program crashes, but a remote one can also simply disappear. That third outcome is the reason for every complication in the chapter — timeouts, retries and at-most-once versus at-least-once semantics.

Common Mistake: Treating RPC as a transparent replacement for a local call. The latency is thousands of times larger and the call can fail on its own, so code that ignores both behaves badly under load.

Important Questions:

• What is marshalling in RPC? Converting the procedure’s parameters into a common representation for transmission, since the two hosts may use different processors, operating systems and data layouts.
• How does a remote procedure call differ from a local one? It crosses a network, so it is far slower and it can fail or be lost entirely, which means the protocol must define timeout, retry and failure semantics.

Chapter 14: Remote login

Part 2: Protocols · Difficulty: Easy · Key topics: telnet, character-based sessions, ssh, host keys, authentication, tunnelling

One of the original motivations for building networks was reaching a remote computer, and this chapter covers how. telnet, defined in RFC 854, is the simplest such protocol: it runs over TCP with the server listening on port 23, and the bidirectional connection carries essentially the characters typed by the user and the text output of processes on the server, in ASCII by default with a later extension for Unicode. Its fatal flaw is stated directly: everything, passwords included, travels in clear text. The rest of the chapter is ssh, which provides the same interactive session over an encrypted and authenticated channel, plus host keys, the authentication methods it supports, and the tunnelling that makes it far more than a login tool.

Key Points:

• telnet runs over TCP; the server listens on port 23 by default.
• A telnet connection is bidirectional and carries the user’s keystrokes and the server’s text output.
• telnet’s default character set is ASCII, with a later extension for Unicode.
• telnet sends everything, including passwords, in clear text — which is why it was replaced.
• ssh provides the same interactive session over an encrypted and authenticated channel.
• ssh verifies the server through a host key and supports password and public-key authentication.

Practice Tip: Use telnet to talk to a plain HTTP or SMTP server by hand, typing the protocol commands yourself. It is the clearest demonstration that these application protocols are just text over a TCP connection — and it also shows exactly why sending a password that way is a bad idea.

Common Mistake: Thinking ssh is only a secure telnet. Port forwarding and tunnelling are core features, and many exam questions are about those rather than the login itself.

Important Questions:

• Why was telnet replaced by ssh? Because telnet transmits everything in clear text, including passwords, so anyone able to capture the traffic can read the whole session.
• What does a host key do in ssh? It identifies the server, so the client can detect if it is connecting to a different machine than the one it trusted before.

Chapter 15: Transport Layer Security

Part 2: Protocols · Difficulty: Hard · Key topics: SSL and TLS, the handshake, certificates, the record protocol, cipher suites, HTTPS

TLS is the security machinery of Chapter 7 applied to real connections. The chapter opens with the naming history — the protocol family was first deployed as Secure Socket Layer, and many people still call it SSL, but TLS is the name the IETF standardized. TLS sits on top of TCP: TCP delivers a reliable byte stream, and TLS encrypts and authenticates the data the application layer sends over it. It is used by many application protocols, most visibly HTTP, where HTTP over TLS is called HTTPS, and also SMTP, POP and IMAP. The chapter then splits TLS into its two halves: the handshake, which negotiates the cipher suite, authenticates the server through its certificate and establishes the session keys, and the record protocol, which carries the encrypted and authenticated data afterwards.

Key Points:

• TLS is the standardized name; SSL was the earlier deployed name for the same protocol family.
• A TLS session runs over a TCP connection: TCP provides reliable delivery, TLS provides encryption and authentication.
• HTTP over TLS is HTTPS; SMTP, POP and IMAP also have TLS variants.
• The handshake negotiates the cipher suite, authenticates the server and establishes the session keys.
• The record protocol carries the encrypted, authenticated application data after the handshake completes.
• The server’s certificate binds its name to its public key and is signed by a certification authority.

Memory Tip: Split TLS in two and it stops being intimidating: the handshake is the expensive part that runs once and agrees on keys, the record protocol is the cheap part that runs for the rest of the connection. Every optimisation in the chapter is about shortening the handshake.

Common Mistake: Believing a valid certificate means the site is trustworthy. It only proves the server holds the private key for that name — an attacker’s own domain can have a perfectly valid certificate.

Important Questions:

• What are the two main parts of TLS? The handshake protocol, which negotiates the cipher suite, authenticates the server and establishes session keys, and the record protocol, which carries the encrypted and authenticated data.
• What is the relationship between TLS and TCP? TLS runs on top of TCP: TCP provides the reliable byte stream and TLS encrypts and authenticates the data carried over it.

Chapter 16: Securing the Domain Name System

Part 2: Protocols · Difficulty: Medium · Key topics: DNS threats, eavesdropping, cache poisoning, DNSSEC, chain of trust, DNS over TLS

DNS is critical infrastructure — it maps the names users type onto IP addresses — so incorrect DNS information sends users to the wrong destination, and the chapter notes that attacks of exactly this kind have happened. It works from the threat analysis in RFC 3833. The first threat is eavesdropping: an attacker who can capture packets sent to a resolver learns which names a user is looking up, and if he can capture all of them he collects a great deal of metadata about that user. Preventing this was never a goal of the original DNS design, which is why carrying DNS over TLS was later discussed in the IETF. The chapter then covers integrity attacks and DNSSEC, which signs DNS records so a resolver can verify them along a chain of trust from the root downward.

Key Points:

• DNS is critical because wrong DNS answers silently send users to the wrong servers.
• RFC 3833 is the reference analysis of the security threats against DNS.
• Eavesdropping on DNS reveals which names a user resolves, which is significant metadata.
• Confidentiality was never a design goal of the original DNS, which is why DNS over TLS was proposed later.
• DNSSEC adds digital signatures to DNS records so a resolver can verify they were not altered.
• DNSSEC builds a chain of trust from the root zone downward; it provides integrity, not confidentiality.

Memory Tip: Keep the two protections apart by what they hide versus what they prove. DNSSEC proves an answer is genuine but everyone can still read the query; DNS over TLS hides the query but does not prove the answer. They solve different problems and are often deployed together.

Common Mistake: Saying DNSSEC encrypts DNS. It signs records for integrity and authenticity; the queries and answers remain readable on the wire.

Important Questions:

• What does DNSSEC protect against? Forged or modified DNS records: it signs records so a resolver can verify their authenticity and integrity through a chain of trust from the root.
• Does DNSSEC provide confidentiality? No. Queries and answers are still visible to anyone who can capture the packets; hiding them requires carrying DNS over TLS instead.

Chapter 17: Internet transport protocols

Part 2: Protocols · Difficulty: Easy · Key topics: transport over a connectionless network layer, UDP vs TCP, SCTP, RTP

A short bridging chapter that frames the two that follow. It restates precisely what the transport layer is given to work with: the Internet’s network layer provides a connectionless service, identifies each host interface by an IP address, and lets hosts transmit packets carrying up to 64 KBytes of payload to any reachable destination — but it does not guarantee delivery, cannot detect transmission errors and does not preserve sequence integrity. Several transport protocols were designed to give applications something richer. The two most widely deployed are UDP and TCP. The chapter also notes SCTP, which appeared in the early 2000s and is used for particular applications such as Voice over IP signalling, and RTP for multimedia, which are not covered further here.

Key Points:

• The Internet’s network layer is connectionless: no delivery guarantee, no error detection, no ordering.
• A network layer packet can carry up to 64 KBytes of payload.
• An IP address identifies an interface of a host, not the host as a whole.
• UDP and TCP are the two most widely deployed Internet transport protocols.
• SCTP appeared in the early 2000s and is used for specific applications such as VoIP signalling.
• RTP includes both transport functions and functions related to encoding multimedia information.

Common Mistake: Skipping this chapter because it is short. The list of what the network layer does not provide is the exact list of things UDP and TCP are judged on in the next two chapters.

Important Questions:

• What service does the Internet network layer provide to the transport layer? A connectionless service that can carry up to 64 KBytes per packet to any reachable host, with no guarantee of delivery, no error detection and no preservation of ordering.
• Which transport protocols are most widely deployed on the Internet? UDP and TCP, with SCTP used for specific applications such as VoIP signalling.

Chapter 18: The User Datagram Protocol

Part 2: Protocols · Difficulty: Easy · Key topics: UDP header, port numbers, checksum, 65467-byte limit, when to choose UDP

UDP, defined in RFC 768, provides an unreliable connectionless transport service on top of the unreliable connectionless network layer. The book states its characteristics precisely: it cannot deliver Service Data Units larger than 65467 bytes; it does not guarantee delivery, so datagrams can be lost or arrive out of sequence; but it will not deliver a corrupted SDU to the destination. The one thing UDP adds over the raw network layer service is worth being clear about — the network layer lets a client send information to a server, but if a particular application on the client wants to reach a particular application on the server, an addressing mechanism beyond the IP address is needed, and that is what UDP’s port numbers provide. The header is only four fields, which is exactly the point.

Key Points:

• UDP is defined in RFC 768 and provides an unreliable connectionless service.
• A UDP SDU cannot be larger than 65467 bytes.
• UDP does not guarantee delivery and does not preserve ordering.
• UDP does detect corruption through its checksum, so a corrupted datagram is discarded, not delivered.
• The main thing UDP adds over the raw network layer is port numbers, so several applications per host can be addressed.
• The UDP header has just four fields: source port, destination port, length and checksum.

Memory Tip: UDP is IP plus ports plus a checksum — nothing else. Whenever a question asks whether UDP does something (retransmit, order, control congestion), the answer is no unless it is one of those three things.

Common Mistake: Describing UDP as “IP with no additions”. The port numbers are exactly the addition, and they are the reason UDP exists at all.

Important Questions:

• What are the characteristics of the UDP service? It cannot carry SDUs larger than 65467 bytes, it does not guarantee delivery or ordering, but it will not deliver a corrupted SDU to the destination.
• What does UDP add compared to the network layer service? Port numbers, which let several applications on one host be addressed separately, plus a checksum that detects corruption.

Chapter 19: The Transmission Control Protocol

Part 2: Protocols · Difficulty: Hard · Key topics: TCP segment format, three-way handshake, sequence numbers, sliding window, retransmission timeout, fast retransmit, connection release

TCP was originally defined in RFC 793, and although many parts have been improved since, the basics are unchanged and an RFC 793 implementation should still interoperate with today’s. It provides a reliable, connection-oriented byte-stream service over IP’s unreliable connectionless service, and it carries the large majority of Internet traffic — many studies have reported more than 90% of the data exchanged. The chapter takes the protocol in the order a connection lives: establishment through the three-way handshake, reliable transfer with sequence numbers and acknowledgements, the sliding window that also provides flow control, computing the retransmission timeout from measured round-trip times, the advanced retransmission strategies such as fast retransmit that avoid waiting for a timeout, and finally connection release.

Key Points:

• TCP was defined in RFC 793 and provides a reliable, connection-oriented byte-stream service over IP.
• TCP carries the large majority of Internet data — studies have reported over 90%.
• A connection is established with a three-way handshake: SYN, SYN+ACK, ACK.
• Sequence numbers count bytes, not segments — TCP delivers a byte stream, not messages.
• The sending window is the smaller of the receiver’s advertised window and the congestion window.
• Flow control protects a slow receiver; congestion control protects the network. They are different mechanisms.
• The retransmission timeout is computed from measured round-trip times, and fast retransmit acts on duplicate acknowledgements without waiting for it.

Memory Tip: Separate the two windows by who they protect. The receive window protects the receiver from being overrun; the congestion window protects the network from being overloaded. TCP always uses the smaller of the two — state that sentence and most window questions solve themselves.

Common Mistake: Treating TCP sequence numbers as segment counters. They number bytes, which is why an acknowledgement points at the next byte expected rather than the last segment received.

Important Questions:

• How is a TCP connection established? By a three-way handshake: the client sends a SYN with its initial sequence number, the server replies with SYN+ACK carrying its own, and the client acknowledges.
• What is the difference between flow control and congestion control in TCP? Flow control uses the receiver’s advertised window to stop a fast sender overwhelming a slow receiver; congestion control uses the congestion window to stop senders overwhelming the network.

Chapter 20: Congestion control

Part 2: Protocols · Difficulty: Hard · Key topics: AIMD in TCP, slow start, congestion avoidance, fast recovery, ssthresh, ECN, modern variants

Congestion control could in principle live in the network layer or the transport layer. The problem was clearly identified in the late 1980s, and the researchers who solved it chose the transport layer — a sensible choice, since that layer already provides reliable delivery and already copes with heterogeneous networks through its self-clocking behaviour. This chapter shows how the AIMD principle from Chapter 5 became TCP’s actual algorithm, originally proposed by Van Jacobson and now specified in RFC 5681. Rather than controlling a transmission rate directly, which would need fine-grained timers, TCP adjusts its congestion window. The phases follow: slow start, which grows the window exponentially until a threshold; congestion avoidance, which grows it by roughly one segment per round trip; and the reaction to loss, with fast retransmit and fast recovery.

Key Points:

• Congestion control was placed in the transport layer, not the network layer, in the late 1980s.
• TCP’s scheme was proposed by Van Jacobson; the current specification is RFC 5681.
• TCP implements AIMD by adjusting the congestion window rather than a rate, because rates need fine-grained timers.
• Slow start grows the window exponentially — the name refers to the small starting point, not to a slow growth rate.
• Above ssthresh, congestion avoidance grows the window by about one segment per round-trip time.
• Packet loss is TCP’s congestion signal; ECN lets routers mark packets instead of dropping them.
• Self-clocking: acknowledgements returning at the bottleneck’s rate naturally pace the sender.

Memory Tip: The name “slow start” is the trap — the growth is exponential, doubling the window every round trip. It is called slow because it starts from one segment instead of blasting a full window immediately. Say that to yourself once and the exam question stops being a trick.

Common Mistake: Confusing congestion control with flow control, or claiming slow start is slow. Both cost easy marks, and both appear in almost every networks paper.

Important Questions:

• What happens during TCP slow start? The congestion window starts at a small value and grows exponentially, roughly doubling every round-trip time, until it reaches the slow start threshold or a loss occurs.
• Why was congestion control implemented in the transport layer? Because that layer already provides reliable delivery and already handles heterogeneous networks through self-clocking, so avoiding congestion fits naturally with what it already does.

Chapter 21: The network layer

Part 2: Protocols · Difficulty: Hard · Key topics: IPv6 addressing architecture, IPv6 packet format, ICMPv6, neighbour discovery, subnets, IPv4 comparison

This is the chapter that makes the book distinctive: it teaches the Internet’s network layer as IPv6 rather than presenting IPv6 as an appendix to IPv4. It begins by analysing what the datalink layer below provides, distinguishing the three types — point-to-point links such as PPP, multipoint LANs, and non-broadcast networks — because the network layer’s behaviour differs on each. It then covers the IPv6 addressing architecture, the fixed-size IPv6 packet header and its extension headers, and ICMPv6, which carries error reporting and, unlike ICMP for IPv4, also carries neighbour discovery. The chapter closes on the IPv6 subnet and how IPv6 interacts with the datalink layer to find the link-layer address for a neighbour.

Key Points:

• The three datalink layer types are point-to-point links, multipoint LANs, and non-broadcast networks.
• PPP, defined in RFC 1661, is the standard point-to-point datalink layer.
• An IPv6 address is 128 bits and identifies an interface, not a host.
• The IPv6 header is fixed size; optional functions moved into extension headers.
• ICMPv6 carries error reporting and also neighbour discovery, which in IPv4 was a separate protocol (ARP).
• IPv6 routers do not fragment packets; the source uses path MTU discovery instead.

Memory Tip: Remember IPv6 by what it removed rather than what it added: no router fragmentation, no header checksum, no separate ARP, no variable-length header. A fixed simple header that routers can process fast is the design goal, and each removal serves it.

Common Mistake: Assuming IPv6 works like IPv4 with longer addresses. Fragmentation, neighbour discovery and the header layout all changed, and questions are usually set on exactly those differences.

Important Questions:

• How does an IPv6 header differ from an IPv4 header? It is a fixed size with optional functions moved into extension headers, it has no header checksum, and routers do not fragment packets.
• What does ICMPv6 do that ICMP for IPv4 did not? It carries neighbour discovery, which resolves a neighbour’s link-layer address — the job done by the separate ARP protocol in IPv4.

Chapter 22: Routing in IP networks

Part 2: Protocols · Difficulty: Hard · Key topics: domains, intradomain vs interdomain routing, IGP, RIP, link state routing, OSPF, areas

The Internet is an interconnection of networks called domains that are under different responsibilities, and at the time of writing there were more than 40,000 of them and the number was still growing. A domain can be a small enterprise with a few routers in one building, a larger enterprise with a hundred routers at multiple sites, or a large ISP with thousands. Two classes of routing protocol serve this structure. Intradomain protocols, also called interior gateway protocols, are used by all the routers inside one domain to exchange information about destinations reachable within it; some domains use RIP, a distance vector protocol, and others use link state routing. This chapter covers that first class in detail, with OSPF as the worked example, including how areas keep link state databases manageable in large domains.

Key Points:

• The Internet is composed of more than 40,000 domains under different administrative responsibilities.
• Intradomain protocols (IGPs) route within one domain; interdomain protocols route between domains.
• RIP is a distance vector protocol: routers exchange their distances to destinations with neighbours.
• OSPF is a link state protocol: routers flood the topology and each computes shortest paths itself.
• Link state routing converges faster than distance vector and avoids the count-to-infinity problem.
• OSPF divides a large domain into areas so that no router has to hold the whole topology.

Memory Tip: Distinguish the two families by what a router sends. Distance vector routers tell their neighbours what they know (“I can reach X in 3 hops”); link state routers tell everyone what they see (“these are my links”). Everything else — convergence speed, count-to-infinity, memory cost — follows from that.

Common Mistake: Using “routing” and “forwarding” interchangeably in an answer. Routing protocols build the tables; forwarding is the per-packet lookup that uses them.

Important Questions:

• What is the difference between intradomain and interdomain routing? Intradomain protocols exchange routing information among the routers of a single domain; interdomain protocols exchange reachability information between different domains under different administrations.
• How does link state routing differ from distance vector routing? In distance vector, each router tells its neighbours its distance to each destination; in link state, each router floods a description of its own links and every router computes the shortest paths from the complete topology.

Chapter 23: Interdomain routing

Part 2: Protocols · Difficulty: Hard · Key topics: autonomous systems, stub and transit domains, multihoming, BGP, path vector, AS path, routing policies, customer-provider and peer-to-peer relationships

Routing between domains is a different problem from routing inside one, because the domains do not trust each other and each wants to enforce its own commercial policy. The chapter counts more than 45,000 domains and divides them into two classes: a stub domain only sends and receives packets whose source or destination is one of its own hosts, while a transit domain forwards packets whose source and destination both lie outside it. About 85% of Internet domains are stubs. A stub connected to a single transit provider is single-homed; one connected to two or more is multihomed. BGP is then presented as the path vector protocol that carries reachability with the full AS path attached, which both prevents loops and gives each domain the information it needs to apply policy.

Key Points:

• The Internet has more than 45,000 domains; about 85% of them are stub domains.
• A stub domain only sources and sinks traffic; a transit domain forwards traffic for others.
• A single-homed stub has one provider; a multihomed stub has two or more.
• BGP is a path vector protocol: each advertisement carries the full list of AS numbers it has crossed.
• The AS path both prevents routing loops and lets a domain apply policy to what it accepts and advertises.
• The two main commercial relationships are customer-provider and peer-to-peer (settlement-free) links.
• BGP selects routes by policy first, not by shortest path — the cheapest route usually wins over the shortest.

Memory Tip: The one sentence that unlocks BGP: inside a domain routing is about finding the shortest path, between domains it is about money. Once you expect policy to override path length, the route selection rules stop looking arbitrary.

Common Mistake: Expecting BGP to pick the shortest AS path. Local preference is applied first, so a domain routinely prefers a longer path through a customer over a shorter one through a provider it has to pay.

Important Questions:

• What is the difference between a stub domain and a transit domain? A stub domain only sends and receives packets whose source or destination is one of its own hosts; a transit domain also forwards packets between other domains.
• Why is BGP called a path vector protocol? Because each route advertisement carries the complete list of autonomous systems the route passes through, which prevents loops and allows each domain to apply its own routing policy.

Chapter 24: Datalink layer technologies

Part 2: Protocols · Difficulty: Medium · Key topics: PPP, Ethernet frame format, MAC addresses, slot time, switches, MAC learning, Spanning Tree Protocol, VLANs, 802.11 WiFi

The final protocol chapter covers the real datalink technologies: PPP for point-to-point links, Ethernet for wired LANs, and 802.11 for wireless. The Ethernet history is worth knowing because its numbers come from it. Ethernet was designed at Xerox PARC in the 1970s, first with a coaxial cable and 3 Mbps; the official specification from Digital Equipment, Intel and Xerox then fixed 10 Mbps and, crucially, a slot time of 51.2 microseconds — a compromise, because a long slot time lets a network span a longer distance but forces a larger minimum frame size, giving Ethernet’s 64-byte minimum. The chapter then moves from the shared cable to switches and MAC address learning, to the Spanning Tree Protocol that keeps a switched network loop-free, to VLANs, and finally to 802.11, where the shared radio spectrum and CSMA/CA make the problem different again.

Key Points:

• PPP, from RFC 1661, is the standard datalink layer for point-to-point links.
• Ethernet was designed at Xerox PARC in the 1970s, first at 3 Mbps over coaxial cable.
• The standard fixed a 10 Mbps rate and a 51.2 microsecond slot time, which gives the 64-byte minimum frame size.
• A longer slot time allows a longer network but forces a larger minimum frame — the minimum frame size is that compromise.
• A switch learns which MAC address is on which port by observing source addresses in arriving frames.
• The Spanning Tree Protocol disables ports to remove loops, because Ethernet frames have no hop count to stop them circulating.
• VLANs split one physical switched network into several logical broadcast domains.

Memory Tip: Ethernet’s 64-byte minimum frame is not arbitrary — it is the slot time expressed in bytes. A station must still be transmitting when a collision from the far end of the cable reaches it, otherwise it would never detect the collision. Learn that one causal chain and the number stops needing memorisation.

Common Mistake: Confusing a hub with a switch. A hub repeats a frame on every port and leaves one collision domain; a switch learns addresses, forwards selectively and gives every port its own collision domain.

Important Questions:

• Why does Ethernet have a minimum frame size of 64 bytes? Because a station must still be transmitting when a collision from the far end of the network reaches it; the 51.2 microsecond slot time chosen for 10 Mbps Ethernet corresponds to that 64-byte minimum.
• Why is the Spanning Tree Protocol needed in a switched network? Ethernet frames carry no hop count, so a loop would let frames circulate forever; STP disables redundant ports to leave a single loop-free path.

Part 3: Exercises and Hands-on Labs (16 sets)

Part 3: Practice · Difficulty: varies · Key topics: sockets programming, packet trace analysis, network building, routing labs

Part 3 is not extra reading — it is sixteen sets of exercises and labs matched to the chapters above, and in the interactive online edition many of them are answered and checked inside the page. The sets cover reliable transfer, sockets for inter-process communication, building a network, serving applications and sharing resources, then application-layer work on email, HTTP and TLS/ssh, then packet trace analysis, two sets on TCP, IPv6 networks, inter-domain routing and routing policies, and finally local area networks with the Spanning Tree Protocol and VLANs. The trace-analysis and socket labs are the ones that pay off fastest, because they turn header diagrams from Part 2 into bytes you have actually looked at.

Key Points:

• The exercise sets follow the chapter order, so each one can be done immediately after its chapter.
• The socket labs cover inter-process communication over both transport services.
• The packet trace exercises have you read real captured traffic rather than idealised diagrams.
• Two separate TCP sets exist: TCP basics and a closer look at TCP.
• The routing labs are split into routing protocols and routing policies, matching Chapters 22 and 23.
• The final set covers LANs, the Spanning Tree Protocol and Virtual LANs.

Practice Tip: Do the packet trace exercises with Wireshark open alongside the TCP and IPv6 chapters. Matching a field in the book’s header diagram to the same field highlighted in a real capture is the single most effective hour you can spend in this course.

Common Mistake: Leaving Part 3 for revision week. These exercises are how the principles in Part 1 become usable; done after the matching chapter they take minutes, done all at once they take days.

Important Questions:

• What kind of exercises does Part 3 contain? Sixteen sets covering reliable transfer, socket programming, building networks, application protocols, packet trace analysis, TCP, IPv6, routing policies and protocols, and local area networks.
• Are the exercises usable without extra software? The interactive online edition checks many answers inside the page; the trace analysis labs are best done with a packet analyser such as Wireshark.

---

Download Computer Networking: Principles, Protocols and Practice PDF (Free)

This book is free from its official source at UCLouvain. Click below to open the official page, where the complete third edition is available as a PDF, as an ePub, and as an interactive online edition in which many of the Part 3 exercises are answered and checked inside the page.

↓ Download PDF

---

How to Study This Book

Read Part 1 in order and do not skip it, even though it names almost no real protocols. Chapters 1, 2 and 5 — reliable transfer, building a network, and sharing resources — are where the marks are, and Part 2 assumes every idea in them. Chapter 6 on the reference models is short and can be read at any point, but read it before your first exam because layer-identification questions are free marks.

Chapter 5 is the largest single block of exam material in the book: the MAC algorithms (ALOHA through CSMA/CA) and AIMD both come from it, and both come back later in Chapters 20 and 24. Give it a full study session on its own.

For Part 2, follow the layers rather than the page order if your course does. The application protocols — Chapters 8 to 16 — are the most approachable and can be read early to build confidence. Chapters 17 to 20 on UDP, TCP and congestion control are the hardest and most heavily examined; read Chapter 5 again before starting Chapter 20, because TCP’s algorithm is just the AIMD principle made concrete.

Chapters 21 to 23 — IPv6, intradomain routing and BGP — are usually the last third of a Pakistani university networks paper. Note that this book teaches the network layer as IPv6 first; if your syllabus is IPv4-based, read Chapter 21 for the concepts and check your own course notes for IPv4 header details and subnetting arithmetic.

Chapter 24 on Ethernet, switches and WiFi is often examined together with Chapter 5, since CSMA/CD and CSMA/CA are defined there and applied here. Read the two close together.

Do the Part 3 exercises for each chapter as you finish it, not at the end. The packet trace and socket labs in particular are what turn the header diagrams into something you can answer questions about under exam conditions.

---

Used In These Programs

This book is used for the Computer Networks and Data Communication courses in: BS Computer Science · BS Information Technology · BS Software Engineering. Browse all Computer Networks books or all Computer Science books.

Who Should Read This

This book is written for upper-level undergraduates taking their first full Computer Networks course, which for most BSCS, BSIT and BSSE students is the fourth or fifth semester. It assumes you can program and are comfortable with basic algorithms, but it assumes no prior networking knowledge and builds every layer from the problem it solves. It suits students who want to understand why protocols are designed the way they are rather than memorise header field lists, and its principles-first structure makes it unusually good for that. It is also a strong choice for anyone preparing for networking certifications or systems interviews, since Chapters 19 to 23 cover TCP, IPv6, OSPF and BGP in real depth. If your paper is heavily IPv4-based — subnetting arithmetic, IPv4 header fields, classful addressing — pair this book with your own course notes, because it deliberately teaches the network layer as IPv6.

---

Applicable Universities

This book is useful for students at Pakistani universities offering BSCS, BSIT and BSSE including Punjab University, Virtual University, COMSATS, FAST, UET, NUST, and other HEC-recognized institutions.

FAQs

Related Books

• Operating Systems and Networks – IT Series BSCS
• Database Management System – BSCS University
• Problem Solving with Algorithms and Data Structures using Python

Computer Networking: Principles, Protocols and Practice is one of the few free textbooks that a university can adopt as its main networking text without compromise. Its principles-first structure, its real depth on TCP, IPv6 and BGP, and its sixteen sets of hands-on exercises make it a complete course rather than just a reference. Browse more Computer Science books for the rest of your semester.

Computer Networking: Principles, Protocols and Practice, third edition, by Olivier Bonaventure, Université catholique de Louvain (Belgium). Free under the Creative Commons Attribution 3.0 (CC BY) licence. Official source: https://www.computer-networking.info/